Operadores de PHP

Un operador toma uno o más valores (llamados operandos) y produce un nuevo valor a partir de ellos. Los operadores son los bloques fundamentales de toda expresión que escribas en PHP — te permiten hacer aritmética, comparar valores, combinar condiciones booleanas, asignar resultados a variables y unir cadenas.

Este capítulo cubre todas las categorías de operadores de PHP con ejemplos ejecutables: aritméticos, de asignación, de comparación, lógicos, de incremento/decremento, de cadena, de array, el operador spaceship, el operador null-coalescing y cómo la precedencia de operadores determina el orden de evaluación.

Operadores Aritméticos

Los operadores aritméticos realizan las operaciones matemáticas habituales sobre números.

<?php
$x = 10;
$y = 3;

echo $x + $y;   // 13
echo $x - $y;   // 7
echo $x * $y;   // 30
echo $x / $y;   // 3.3333333333333
echo $x % $y;   // 1   (remainder of 10 / 3)
echo $x ** $y;  // 1000 (10 to the power of 3)

Nota: A diferencia de muchos lenguajes, el / de PHP no trunca. 10 / 4 es 2.5, no 2. Usa intdiv() para la división entera. El operador % funciona con enteros; para restos con coma flotante usa fmod().

Operadores de Asignación

El operador de asignación básico es = — almacena el valor de la derecha en la variable de la izquierda. Cada operador aritmético también tiene una forma combinada (compuesta) que actualiza una variable en su lugar.

<?php
$total = 100;
$total += 20;  // 120
$total -= 50;  // 70
$total *= 2;   // 140
echo $total;   // 140

Operadores de Comparación

Los operadores de comparación comparan dos valores y devuelven un boolean (true o false). Observa la distinción importante entre la comparación flexible (==) y la estricta (===).

<?php
var_dump(10 == "10");   // bool(true)  — values match after juggling
var_dump(10 === "10");  // bool(false) — int vs string, types differ
var_dump(5 != 8);       // bool(true)
var_dump(5 >= 5);       // bool(true)

Advertencia: Prefiere === cuando te importe el tipo. 0 == "abc" es false en PHP moderno (8.0+), pero la comparación flexible aún tiene casos límite sorprendentes — la comparación estricta los evita.

El operador spaceship <=>

El operador spaceship compara dos valores y devuelve -1, 0 o 1. Es más útil como valor de retorno de un callback de ordenación.

<?php
echo 1 <=> 2;   // -1  (left is smaller)
echo 2 <=> 2;   //  0  (equal)
echo 3 <=> 2;   //  1  (left is larger)

Operadores Lógicos

Los operadores lógicos combinan expresiones booleanas, generalmente dentro de condiciones if.

<?php
$age = 25;
$hasLicense = true;

var_dump($age >= 18 && $hasLicense);  // bool(true)
var_dump($age < 18 || $hasLicense);   // bool(true)
var_dump(!$hasLicense);               // bool(false)

&& y and se comportan igual en condiciones pero tienen precedencia diferente — and/or se unen de forma más laxa que =, lo que puede sorprenderte. Usa siempre && y ||.

PHP también realiza evaluación en cortocircuito: en $a && expensive(), si $a es false, el lado derecho nunca se evalúa.

Operadores de Incremento y Decremento

Estos operadores suman o restan 1 a una variable. Su posición (pre vs post) cambia lo que evalúa la expresión.

<?php
$x = 5;
echo $x++;  // 5  (prints old value, then $x becomes 6)
echo $x;    // 6
echo ++$x;  // 7  (increments first, then prints)

Operadores de Cadena

PHP tiene dos operadores dedicados a las cadenas:

• . — el operador de concatenación, une dos cadenas.
• .= — el operador de asignación con concatenación, añade al final de la variable.

<?php
$greeting = "Hello";
$greeting .= ", World!";   // append
echo $greeting;            // Hello, World!
echo "PHP" . " " . "rocks"; // PHP rocks

Operadores de Array

Los operadores de array trabajan sobre arrays completos.

<?php
$a = ["a" => 1, "b" => 2];
$b = ["b" => 99, "c" => 3];

print_r($a + $b);
// Array ( [a] => 1 [b] => 2 [c] => 3 )
// "b" keeps the LEFT value (2), "c" is added

Operador Null-Coalescing ??

El operador ?? devuelve su operando izquierdo si existe y no es null, de lo contrario el operando derecho. Es el reemplazo limpio para las comprobaciones con isset().

<?php
$data = ["name" => "Ann"];

$name = $data["name"] ?? "Guest";  // "Ann"
$role = $data["role"] ?? "Member"; // "Member" — key missing, no warning
echo "$name / $role";              // Ann / Member

La asignación null-coalescing ??= asigna solo cuando la variable es actualmente null o no está definida: $config["theme"] ??= "dark";.

Precedencia de Operadores

Cuando una expresión mezcla operadores, la precedencia decide cuál se ejecuta primero, igual que en matemáticas (* antes que +). Usa paréntesis para hacer explícita la intención y anular los valores predeterminados.

<?php
echo 2 + 3 * 4;     // 14  — * binds tighter than +
echo (2 + 3) * 4;   // 20  — parentheses force addition first

De mayor a menor, algunos niveles clave: **, luego !, luego * / %, luego + -, luego comparación (< > == ===), luego &&, luego ||, y finalmente =. Ante la duda, añade paréntesis — no tienen ningún coste y previenen errores.

Resumen

• Aritméticos (+ - * / % **) operan sobre números; / devuelve un float, % devuelve el resto.
• Asignación (= += .= …) almacena y actualiza valores; las formas compuestas son abreviaciones.
• Comparación (== === != <=>) devuelve booleanos — prefiere el estricto === para evitar sorpresas por conversión de tipos.
• Lógicos (&& || !) combina condiciones y realiza cortocircuito.
• Incremento/decremento (++ --) difieren por la posición pre/post.
• Cadena (. .=) une texto; array (+ == ===) compara y fusiona arrays.
• ?? proporciona valores predeterminados para valores ausentes; la precedencia y los paréntesis controlan el orden de evaluación.

A continuación, pon estos operadores en práctica dentro de sentencias condicionales y bucles.

Práctica