---
title: "Operadores en PHP: la guía completa"
excerpt: "Todos los operadores de PHP en un solo lugar: aritméticos, de asignación, de comparación, lógicos, de cadena, de incremento, bit a bit, ternario y null coalescing, con ejemplos y los gotchas que más confunden."
date: "2026-06-16T00:00:00.000Z"
lastModified: "2026-06-16T00:00:00.000Z"
category: "PHP"
author:
  name: "angel cruz"
  picture: "https://angelcruzdevcdn.nyc3.cdn.digitaloceanspaces.com/images/me/angel-cruz.png"
ogImage:
  url: "/images/open-graph/php-opengraph-image.png"
seo_title: "Operadores en PHP: tipos, sintaxis y ejemplos (2026)"
seo_description: "Guía de los operadores de PHP con ejemplos: aritméticos, de comparación (== vs ===), lógicos, ternario, null coalescing (??) y el spaceship (<=>). Con gotchas reales."
tech_article:
  article_section: "PHP Fundamentals"
  keywords: "operadores php, operadores en php, operadores de comparacion php, operadores logicos php, null coalescing php, operador spaceship php"
---

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 | `&&` `||` `!` `and` `or` `xor` |
| 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:

```php
$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:

```php
$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 `===`.

```php
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](/post/igual-vs-identico-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`).

```php
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](/post/operador-spaceship-php)**.

## Operadores lógicos

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

```php
$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:

```php
$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 `+`:

```php
$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

```php
$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:

```php
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:

```php
// 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](/post/el-operador-ternario-php)** — sintaxis a fondo, operador Elvis y null coalescing.
- **[10 ejemplos prácticos del operador ternario](/post/10-ejemplos-operador-ternario-php)** — casos de uso reales: validaciones, clases CSS dinámicas, respuestas de API y más.
- **[Null coalescing en PHP (`??` y `??=`)](/post/null-coalescing-php)** — 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
// 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](/post/el-operador-ternario-php).

---

## Sitemap

Índice completo del sitio: [/sitemap.md](https://www.angelcruz.dev/sitemap.md)

Canónico HTML: [https://www.angelcruz.dev/post/operadores-php](https://www.angelcruz.dev/post/operadores-php)