Operadores en PHP: tipos, sintaxis y ejemplos (2026)

Un operador en PHP es un símbolo que toma uno o más valores (los operandos) y produce otro. Sumar, comparar, asignar, concatenar texto: todo pasa por operadores. Esta guía los reúne todos por categoría, con ejemplos cortos y los detalles donde la mayoría tropieza. Para los temas con más tela —el operador ternario, por ejemplo— hay artículos dedicados enlazados desde cada sección.

Tabla de referencia rápida

Categoría	Operadores
Aritméticos	`+` `-` `` `/` `%` `*`
Asignación	`=` `+=` `-=` `=` `/=` `%=` `*=` `.=` `??=`
Comparación	`==` `===` `!=` `<>` `!==` `<` `>` `<=` `>=` `<=>`
Lógicos	`&&` `
De cadena	`.` `.=`
Incremento / decremento	`++` `--`
Bit a bit	`&` `
Ternario y null coalescing	`? :` `?:` `??` `??=`

Operadores aritméticos

Los de toda la vida, más dos que conviene tener presentes:

$a = 10;
$b = 3;
 
echo $a + $b;   // 13
echo $a - $b;   // 7
echo $a * $b;   // 30
echo $a / $b;   // 3.3333333333333
echo $a % $b;   // 1   (resto de la división entera)
echo $a ** $b;  // 1000 (exponenciación: 10 elevado a 3)

Dos detalles que sorprenden:

% trabaja con enteros. Convierte ambos operandos a int antes de operar. Si necesitas el resto de una división con decimales, usa fmod($a, $b).
** es asociativo por la derecha. 2 ** 3 ** 2 se evalúa como 2 ** (3 ** 2), o sea 2 ** 9 = 512, no 64.

Operadores de asignación

Además del = clásico, cada operador aritmético o de cadena tiene su versión combinada, que opera y asigna en un paso:

$total = 100;
$total += 50;   // 150  (equivale a $total = $total + 50)
$total -= 20;   // 130
$total *= 2;    // 260
$total .= " USD"; // "260 USD"  (concatena y asigna)
 
$config ??= 'valor por defecto'; // asigna solo si $config es null o no existe

El último, ??= (asignación coalescente, desde PHP 7.4), es de los más útiles: asigna el valor de la derecha solo si la variable de la izquierda es null o no está definida. Equivale a $config = $config ?? 'valor por defecto'; pero sin repetir la variable.

Operadores de comparación

Aquí vive el malentendido más común de PHP: la diferencia entre == y ===.

var_dump(5 == "5");   // true  — compara el valor tras convertir tipos
var_dump(5 === "5");  // false — exige mismo valor Y mismo tipo
var_dump(5 != "6");   // true
var_dump(5 !== "5");  // true  — distinto tipo, así que no son idénticos

== (igual) compara valores aplicando conversión de tipos. 5 == "5" es true porque PHP ajusta los tipos antes de comparar.
=== (idéntico) exige el mismo valor y el mismo tipo. Es la comparación segura y la que deberías usar por defecto.

Esta distinción tiene más tela de la que parece —el cambio de PHP 8, los gotchas de switch e in_array(), cómo comparar arrays y objetos—, así que la desarrollo aparte en == vs === en PHP.

El operador spaceship `<=>`

Desde PHP 7, el operador nave espacial compara dos valores y devuelve un entero: menor que cero si el izquierdo es menor, cero si son iguales, mayor que cero si el izquierdo es mayor (en la práctica, -1, 0 o 1).

echo 1 <=> 2;  // -1
echo 2 <=> 2;  //  0
echo 3 <=> 2;  //  1
 
// Su uso estrella: ordenar sin escribir la lógica de comparación a mano
$numeros = [3, 1, 2];
usort($numeros, fn($a, $b) => $a <=> $b); // [1, 2, 3]

Si vas a ordenar de verdad —arrays de datos, varios criterios, ascendente y descendente—, lo cubro a fondo en el operador spaceship (<=>) en PHP.

Operadores lógicos

Combinan expresiones booleanas. Hay dos juegos: los símbolos (&&, ||, !) y las palabras (and, or, xor).

$activo = true;
$verificado = false;
 
var_dump($activo && $verificado); // false — ambos deben ser true
var_dump($activo || $verificado); // true  — basta con uno
var_dump(!$verificado);           // true  — niega el valor
var_dump($activo xor $verificado);// true  — true solo si difieren

El gotcha de and / or: no son intercambiables con && / ||. Las palabras tienen menor precedencia que =, así que esto no hace lo que parece:

$resultado = true and false;
var_dump($resultado); // true (!)
// Se evalúa como: ($resultado = true) and false;
// La asignación ocurre antes que el "and".
 
$resultado = true && false;
var_dump($resultado); // false — este es el comportamiento esperado

Regla práctica: usa siempre && y ||. Deja and / or fuera salvo que sepas exactamente por qué los necesitas.

Operadores de cadena

PHP concatena texto con el punto, no con +:

$nombre = "Angel";
$saludo = "Hola, " . $nombre; // "Hola, Angel"
$saludo .= "!";               // "Hola, Angel!"  (concatena y asigna)

Ojo con la precedencia en PHP 8: desde esa versión, + y - tienen mayor prioridad que .. Por eso echo "Suma: " . 1 + 2; evalúa 1 + 2 primero. Si mezclas aritmética y concatenación en la misma línea, usa paréntesis: "Suma: " . (1 + 2).

Operadores de incremento y decremento

$n = 5;
echo $n++; // 5  (post-incremento: usa el valor y luego suma)
echo $n;   // 6
echo ++$n; // 7  (pre-incremento: suma y luego usa el valor)
 
echo $n--; // 7  (post-decremento)
echo --$n; // 5

La diferencia entre pre y post solo importa cuando usas el valor en la misma expresión. Curiosidad: PHP también incrementa cadenas ($s = "a"; $s++; da "b"), aunque no las decrementa.

Operadores bit a bit

Operan sobre la representación binaria de los enteros. Se ven poco en el día a día, pero aparecen en permisos, flags y optimizaciones:

echo 6 & 3;  // 2  (AND bit a bit)
echo 6 | 3;  // 7  (OR bit a bit)
echo 6 ^ 3;  // 5  (XOR bit a bit)
echo ~6;     // -7 (NOT: invierte todos los bits)
echo 1 << 3; // 8  (desplaza bits a la izquierda: 1 * 2^3)
echo 16 >> 2;// 4  (desplaza a la derecha: 16 / 2^2)

Operador ternario y null coalescing

El ternario condensa un if-else en una sola expresión, y el null coalescing maneja valores que pueden no existir:

// Ternario completo
$mensaje = ($edad >= 18) ? 'Adulto' : 'Menor';
 
// Ternario corto (operador Elvis): si el valor es truthy lo devuelve, si no, el fallback
$nombre = $input ?: 'Invitado';
 
// Null coalescing: devuelve la izquierda si existe y no es null
$usuario = $_GET['user'] ?? 'anónimo';

La diferencia clave entre ?: y ??: el Elvis evalúa truthiness (un string vacío "" dispara el fallback), mientras que ?? solo mira si el valor es null o no está definido. Es el operador que más tela tiene, así que lo desarrollo en artículos aparte:

El operador ternario en PHP — sintaxis a fondo, operador Elvis y null coalescing.
10 ejemplos prácticos del operador ternario — casos de uso reales: validaciones, clases CSS dinámicas, respuestas de API y más.
Null coalescing en PHP (?? y ??=) — valores por defecto sin warnings y la diferencia con el Elvis.

El gotcha que cambió en PHP 8: `==` con strings

Si vienes de PHP 7, este cambio te puede morder. Al comparar un número con un string no numérico, PHP 8 convierte el número a string en lugar de convertir el string a 0:

// PHP 7: true   |  PHP 8: false
var_dump(0 == "foo");

En PHP 7, "foo" se convertía a 0 y la comparación daba true (una fuente clásica de bugs). PHP 8 lo arregló. Es una razón más para usar === siempre que puedas.

Precedencia: cuando dudes, usa paréntesis

PHP tiene una tabla de precedencia larga (qué operador se evalúa antes que cuál). Memorizarla entera no vale la pena. Lo importante: ** se evalúa antes que * y /, que van antes que + y -; las comparaciones van después; y los lógicos al final. Cuando una expresión mezcla varios tipos y no estás seguro, los paréntesis dejan la intención explícita y evitan sorpresas.

Preguntas frecuentes

¿Cuál es la diferencia entre `==` y `===` en PHP?

== compara solo el valor, aplicando conversión de tipos (5 == "5" es true). === exige el mismo valor y el mismo tipo (5 === "5" es false). Usa === por defecto: evita bugs de conversión de tipos.

¿Qué hace el operador `??` en PHP?

El null coalescing devuelve su operando izquierdo si existe y no es null; de lo contrario, devuelve el derecho. Sirve para valores por defecto sin generar warnings: $nombre = $_GET['user'] ?? 'anónimo';. Desde PHP 7.4 existe ??= para asignar solo cuando la variable es null.

¿Qué es el operador `<=>` (spaceship)?

Compara dos valores y devuelve un entero menor, igual o mayor que cero según el izquierdo sea menor, igual o mayor que el derecho. Su uso más común es como función de comparación en usort() para ordenar arrays.

¿Por qué `and` no es lo mismo que `&&`?

Hacen la misma operación lógica, pero and y or tienen menor precedencia que el operador de asignación =. Eso provoca resultados inesperados como $x = true and false; (que asigna true a $x). Usa && y || para evitarlo.

Cierre

Los operadores son el vocabulario básico de PHP, y casi todos son intuitivos salvo tres puntos: la diferencia entre == y ===, la precedencia de and/or frente a =, y cuándo usar ?: o ??. Si tienes esos tres claros, el resto es cuestión de tener la tabla a mano. Para profundizar en el condicional más versátil, sigue con la guía del operador ternario en PHP.