Operadores lógicos y de comparación en PHP

Hola, ¿cómo están? Continuando con el curso de PHP, hoy veremos los operadores de comparación y los operadores lógicos. Son los que permiten a un programa tomar decisiones, así que son la base de todo lo que viene en las próximas lecciones.

¡Empecemos!

Operadores de comparación

Comparan dos valores y devuelven siempre true o false.

<?php
$a = 10;
$b = 5;

var_dump($a > $b);    // true   mayor que
var_dump($a < $b);    // false  menor que
var_dump($a >= 10);   // true   mayor o igual
var_dump($a <= 9);    // false  menor o igual
var_dump($a == $b);   // false  igual
var_dump($a != $b);   // true   distinto

Hasta aquí no hay sorpresas. La sorpresa viene ahora.

La diferencia entre == y ===

Esto es lo más importante de esta lección, y la fuente número uno de errores difíciles de encontrar en PHP.

<?php
var_dump(5 == "5");    // true
var_dump(5 === "5");   // false

• == compara solo el valor, y para hacerlo convierte los tipos si hace falta. Se le llama comparación laxa.
• === compara valor y tipo. Se le llama comparación estricta.

En el ejemplo, 5 es un número y "5" es una cadena de texto. Con == PHP convierte y dice que son iguales; con === reconoce que son cosas distintas.

Por qué importa de verdad

Mira este caso:

<?php
$respuesta = "0";

if ($respuesta == false) {
    echo "Entra aquí";   // y entra
}

La cadena "0" se considera falsa en una comparación laxa. Situaciones así aparecen constantemente cuando lees datos de un formulario, porque todo lo que llega de un formulario es texto, aunque el usuario haya escrito un número.

La regla práctica: usa siempre === salvo que tengas una razón concreta para no hacerlo. Te va a ahorrar horas de depuración.

Lo mismo aplica al operador de desigualdad: prefiere !== sobre !=.

Valores que PHP considera falsos

Conviene tener esta lista presente, porque explica muchos comportamientos raros:

<?php
var_dump((bool) false);   // false
var_dump((bool) 0);       // false
var_dump((bool) 0.0);     // false
var_dump((bool) "");      // false
var_dump((bool) "0");     // false
var_dump((bool) []);      // false  array vacío
var_dump((bool) null);    // false

Todo lo demás es verdadero, incluidos "false", "0.0", -1 y " " (un espacio).

El operador nave espacial

Compara dos valores y devuelve -1, 0 o 1:

<?php
echo 1 <=> 2;   // -1  el primero es menor
echo 2 <=> 2;   //  0  son iguales
echo 3 <=> 2;   //  1  el primero es mayor

Se llama así por su forma, <=>. Su uso real es ordenar arrays, y lo verás cuando lleguemos a esa lección.

Operadores lógicos

Combinan varias condiciones en una sola.

AND: se cumplen todas

<?php
$edad = 25;
$tieneCarnet = true;

if ($edad >= 18 && $tieneCarnet) {
    echo "Puede conducir";
}

&& devuelve verdadero solo si ambas condiciones lo son.

OR: se cumple al menos una

<?php
$esAdmin = false;
$esEditor = true;

if ($esAdmin || $esEditor) {
    echo "Puede editar el contenido";
}

|| devuelve verdadero si al menos una condición lo es.

NOT: invierte

<?php
$activo = false;

if (!$activo) {
    echo "La cuenta está desactivada";
}

El ! invierte el resultado: convierte verdadero en falso y viceversa.

XOR: una sí, la otra no

<?php
var_dump(true xor false);   // true
var_dump(true xor true);    // false

Devuelve verdadero cuando exactamente una de las dos condiciones lo es. Se usa poco, pero conviene conocerlo.

&& o and: cuidado con la diferencia

PHP acepta también las palabras and, or y not, y parecen equivalentes. No lo son: tienen menor precedencia y eso puede darte resultados inesperados.

<?php
$resultado = true and false;
var_dump($resultado);   // true, no false

Lo que ocurre es que la asignación = se resuelve antes que and, así que $resultado recibe true y el and false queda suelto.

Usa siempre && y ||. Las versiones en palabras existen por compatibilidad histórica y solo traen problemas.

Evaluación de cortocircuito

PHP deja de evaluar en cuanto conoce el resultado. Con &&, si la primera condición es falsa, la segunda ni se ejecuta:

<?php
if (isset($usuario) && $usuario->esAdmin()) {
    // ...
}

Ese orden importa: si $usuario no existe, la segunda parte no llega a ejecutarse y no hay error. Al revés, el programa reventaría.

Es un patrón que vas a usar muchísimo. Comprueba primero que algo existe, después úsalo.

Combinar condiciones

Cuando mezclas && y ||, el && se evalúa primero. Igual que en aritmética, usa paréntesis:

<?php
$edad = 20;
$esSocio = false;
$esEstudiante = true;

if ($edad >= 18 && ($esSocio || $esEstudiante)) {
    echo "Tiene descuento";
}

Sin los paréntesis, la condición significaría algo distinto.

Comparar cadenas de texto

Para comparar texto, === funciona bien, pero distingue mayúsculas:

<?php
var_dump("Hola" === "hola");   // false

// Comparación sin distinguir mayúsculas:
var_dump(strcasecmp("Hola", "hola") === 0);   // true

Un ejemplo práctico

Validemos el acceso a una zona restringida:

<?php
$usuario = "victor";
$rol = "editor";
$activo = true;
$intentos = 2;

if ($activo && ($rol === "admin" || $rol === "editor") && $intentos < 3) {
    echo "Acceso permitido";
} else {
    echo "Acceso denegado";
}

Se lee casi como una frase: la cuenta está activa, y el rol es admin o editor, y no superó los intentos.

Para cerrar

Si te llevas una sola cosa de esta lección, que sea usar === en lugar de ==. Es el cambio de hábito que más errores evita en PHP.

En la siguiente lección usaremos todo esto dentro de estructuras condicionales.

Saludos y éxitos.