Operadores y datos truthy & falsy en PHP

Una característica común a todos los lenguajes de programación -y, por tanto, también a PHP- además de las variables, es la de los operadores.
Podríamos imaginar un operador como una pequeña caja mágica en la que añadiremos algo -nuestros operandos- y nos saldrá algo diferente a lo que hemos insertado -nuestro resultado-.

Los operadores, por tanto, realizan una operación teniendo los operandos disponibles.

Analizaremos tres tipos:

1. operadores matemáticos
2. operadores de comparación
3. operadores lógicos

OPERADORES MATEMÁTICOS

Los operadores matemáticos actúan sobre uno o más operandos y devuelven un valor numérico.
Estos operadores, por lo tanto, recuerdan las operaciones matemáticas que representan:

• el + para la adición
• el - para la resta
• el * para la multiplicación
• el / para la división
• el % para el módulo
• el ** para el exponencial

Veámoslos trabajando en dos operandos que, para nosotros, serán:

• $a=5
• $b=2

Adición (suma de los operandos)

Mediante este operador matemático se realizará la suma entre los valores dados en el momento de la inicialización de las variables (en este caso 5+2 dará como resultado 7)

Resta (Diferencia entre los operandos)

$a- $b significa que literalmente estamos restando 5-2 y por lo tanto el resultado será 3

Multiplicación (Producto entre los operandos)

de manera similar, $a * $b devolverá 10 como resultado (porque 5*2 = 10)

División (Cociente entre los operandos)

$a / $b significa que en realidad estamos dividiendo 5 entre 2 y nos devolverá un número en coma flotante que corresponde a su resultado, es decir 2.5 (recuerda que en php el punto flotante en los números se indica con un punto).

Módulo (Resto de operandos)

Cuando hablamos de módulo nos referimos al resto de operandos. El resto es la cantidad que "sobró" después de hacer la división, es decir, aquella cantidad que no se pudo dividir para que el resultado coincidiera con un número entero. Con $a% $b queremos saber lo que ha quedado de la división entre 5 y 2.
Los dos "entran el 5" dos veces, y la diferencia obtenida es 1; el resto de dividir 5 por 2 es, por tanto, 1. Y este será exactamente el resultado de nuestro módulo.

Exponencial (a elevado a la potencia de b)

Cuando queremos multiplicar un número muchas veces por sí mismo, lo mejor es no usar el operador de multiplicación, sino el exponencial.
Esto se debe a que, por ejemplo, 5* 5* 5* 5* 5 equivale a escribir 5 elevado a la potencia de 5.

Volviendo, por tanto, a nuestros dos operandos, con $a ** $b estamos elevando 5 a la potencia de 2 (también podríamos decir "cinco a la segunda"). Esto es equivalente a escribir 5x5, con un resultado de 25.

Ahora intentemos usar nuestros operadores matemáticos en PHP.

<?php
   $x = 5;
   $y = 2;
   var_dump( $x + $y);
   var_dump( $x - $y);  
   var_dump( $x * $y);  
   var_dump( $x / $y);
   var_dump($x % $y);
?>
Nuestro output será:

P.D. Usamos, en el ejemplo, una función php (var_dump) que nos permite ver el tipo de datos en la salida para tener una visión más clara de los resultados. No te preocupes, hablaremos de las funciones de php en detalle en las próximas guías, para que puedas aprender php de forma clara y gradual.

OPERADORES DE COMPARACIÓN

Los operadores de comparación actúan sobre dos operandos y devuelven un valor booleano (es decir, un valor que puede ser verdadero o falso: ¿recuerdas?).
Imaginemos que tenemos un triángulo y un cubo como operandos.
Ahora hagámonos una serie de preguntas.

¿Es el triángulo lo mismo que el cubo? ¡Absolutamente falso!
¿Es el triángulo diferente del cubo? ¡ Cierto, sin duda!
¿Es el triángulo más grande que el cubo? Si lo notamos, la respuesta, por supuesto, será cierta.

Lo que puede parecer una obviedad, aplicado al mundo de la programación informática, cobra cierta importancia.

Salgamos de la metáfora e intentemos considerar dos operandos $c y $d para analizar en detalle todos nuestros operadores de comparación.

Igual ( == )
 $c == $d sustituye TRUE si $c es igual a $d, FALSE en caso contrario

Idéntico ( === )
$c === $d sustituye TRUE si $c es igual a $d, y también son datos del mismo tipo, FALSE en caso contrario

Muy importante es la diferencia entre == y ===:

== comprueba si los dos operados tienen el mismo valor.
=== comprueba si los dos operandos son iguales en valor pero también en tipos de datos.

¡Regresemos a nuestra metáfora! Pero, en esta ocasión, nuestros operadores serán dos cubos: uno de piedra y otro de plástico.
El primer operador, por tanto, devolverá VERDADERO ya que en realidad son dos cubos: su valor es igual.
El segundo operador, por otro lado, devolverá FALSO porque los dos cubos están hechos de diferentes materiales: uno está hecho de piedra, el otro de plástico. Dos tipos diferentes. ¿Queda claro ahora?

No idénticos ( !== )

$c !== $b sustituye TRUE si $c no es igual en valor a $b, y ni siquiera son del mismo tipo, FALSE en caso contrario. ¿Empiezas a entender el mecanismo?

No iguales ( != )

$c != $d sustituye TRUE si $c no es igual a $d, FALSE en caso contrario

También hay otra sintaxis para verificar si dos operandos no son iguales y es $c <> $d 

Menores que ( < )

$c < $d sustituye TRUE si $c es más pequeño que $d, FALSE en caso contrario

Mayor que ( > )

$c > $d sustituye TRUE si $c es más grande que $d, FALSE en caso contrario

Menor o igual ( <= )

$c <= $d sustituye TRUE si $c es más pequeño o igual a $d, FALSE en caso contrario

Mayor o igual ( => )

$c >= $d sustituye TRUE si $c es más grande o igual a $d, FALSE en caso contrario

Probémoslos en php:

<?php
   $c = 20;
   $d = 10;
   var_dump( $c == $d);
   var_dump( $c != $d);
   var_dump( $c <> $d);
   var_dump( $c < $d);
   var_dump( $c > $d);
   var_dump( $c <= $d);
   var_dump( $c >= $d);
?>
Nuestro output será:

Hagámos ahora otros ejemplos:

<?php
   $a = 10;
   $b = "10";
   var_dump( $a == $b); //true porque los dos numeros tienen el mismo valor
   var_dump( $a === $b); //false porque los dos numeros son iguales en valor pero NO EN TIPO 
   var_dump( $a != $b); //false porque los dos numeros tienen el mismo valor
   var_dump( $a !== $b); //true porque los dos numeros son iguales en valor pero NO EN TIPO
?>
Nuestro output será:

Como puedes ver, en el último ejemplo, las dos variables son de diferentes tipos: una es un número y la otra es una cadena.

Sin embargo, también podríamos aplicar algunas operaciones, ya que php reconoce una cadena numérica: analiza, es decir, comenzando desde la izquierda, carácter por carácter y si reconoce un número, lo usará como el número real; sin embargo, si identifica un carácter inmediatamente después, devolverá un error.

Veamos directamente ejemplos en php:

<?php
   $a = 10;
   $b = "10";
   echo "PRIMER RESULTADO \n";
   echo $a + $b;
   echo "\n";

   $a = 10;
   $b = "10ciao";
   echo "SEGUNDO RESULTADO \n";
   echo $a + $b;
   echo "\n";

   $a = 10;
   $b = "ciao10";
   echo "TERCER RESULTADO \n"
   echo $a + $b;
?>

El output será:

El primer resultado es la suma normal;
en el segundo PHP nos muestra una advertencia, pero de alguna manera logra devolvernos una suma.
En el tercero, sin embargo, tenemos un error fatal.

OPERADORES LÓGICOS

Antes de definir qué son los operadores lógicos y verlos en acción, necesitamos especificar dos conceptos muy importantes.
Hablamos de los conceptos de dato truthy y dato falsy.

DATOS TRUTHY

Un dato se define truthy cuando es cuantificable y contiene un valor distinto de cero.

Algunos ejemplos pueden ser:

Números distintos de cero;
Cadenas no vacías;
Matrices no vacías (ejemplo: [3, 'D', 2.3, "Hola"]);
El valor booleano True.

DATOS FALSY

Un dato es falsy, en cambio, cuando contiene un valor nulo o no cuantificable. Por ejemplo:

0;

Cuerda vacía;
Matriz vacía (ejemplo []);
El valor booleano Falso.

Algunos ejemplos en php:

<?php
   var_dump((bool) ""); // false
   var_dump((bool) " "); //true
   var_dump((bool) 1); //true
   var_dump((bool) -2); //true
   var_dump((bool) "foo"); //true
   var_dump((bool) 2.35); //true
   var_dump((bool) [12]); //true,
   var_dump((bool) []); // false
   var_dump((bool) "false"); //true
?>

Nuestro output:

Dicho esto, podemos volver a nuestros operadores lógicos.
Los operadores lógicos actúan sobre dos operandos y devuelven un valor booleano verdadero o falso y son:

•  AND cuya sintaxis es el doble "ampersand" &&
•  OR se indica con doble "tubo", también llamado "barra vertical" || 
•  NOT  se indica con el signo de exclamación !

El operador AND se vuelve true SI Y SOLO SI ambos operandos son valores truthy.

Ejemplos en php: 

<?php
   var_dump(true && true);     //true
   var_dump(true && false);    //false
   var_dump(false && true);    //false
   var_dump(false && false);   //false
?>

Nuestro output:

El operador OR se vuelve true SI AL MENOS UNO de los operandos es un valor truthy.

Ejemplo en php: 

<?php
   var_dump(true || false);  //true
   var_dump(false || true);  //true
   var_dump(true || true);     //true
   var_dump(false || false);   //false
?>

Nuestro output será:

El operador NOT se vuelve el booleano inverso.
Por ejemplo, aplicado a un valor truthy se volverá falso y viceversa.

Ejemplo en php: 

<?php
   var_dump(!true);  //false
   var_dump(!false);  //true
?>

Nuestro output:

ATENCIÓN

Los operadores && y || tienen una peculiaridad que no debe subestimarse. Consideremos las reglas que acabamos de ver, que establecen que Y es verdadero SI Y SOLO SI ambos operandos son verdaderos y O es verdadero si AL MENOS UNO DE LOS DOS es verdadero ¿Cómo se lleva a cabo la evaluación? Se realizará de izquierda a derecha. Entendamos cómo.

Supongamos que tenemos nuestros dos operadores que, esta vez, serán dos manzanas.
Preguntémonos: ¿son manzanas amarillas? La respuesta será sí si ambos son amarillos.

¿Cómo hará nuestro operador and para resolver esto? Sencillo: comprobará si la primera manzana es amarilla y luego tendrá que comprobar si la segunda también es amarilla.
Si la primera fuera, por ejemplo, verde, de nada le serviría comprobar la segunda, que en ese momento podría ser de cualquier otro color: al operador no le importará, ya que la respuesta ya será "las manzanas no son las dos amarillas". El valor devuelto, por lo tanto, será falso.

¿Una de las dos manzanas es amarilla?
Si una de las dos manzanas es realmente amarilla, la respuesta será sí. Pero será nuestro operador or para averiguarlo. ¿Cómo? Comprobará la primera manzana, y si esta es amarilla, el operador no necesitará comprobar la segunda: una de las dos es del color que busca. Si, por el contrario, la primera manzana no es amarilla, el operador or deberá, inevitablemente, ir a comprobar la segunda. En ese punto, la respuesta será "verdadera" si la segunda manzana es del color que el operador está buscando, y "falsa" en caso contrario.

Entonces, ¿está claro qué sucede cuando usamos and (&&) o el or (||)?
Repitámoslo: se evalúan los primeros datos y, si es posible comprender si la respuesta es verdadera o falsa a partir de la primera verificación, los segundos datos no se considerarán; si, por el contrario, el control del primer dato no es suficiente para darnos una respuesta, entonces se evaluará y considerará el segundo.

Algunos ejemplos en php: 

<?php
   var_dump(5 && "pippo"); //TRUTHY && TRUTHY
   var_dump(" " && 0); //TRUTHY && FALSY
   var_dump(null && true); //FALSY && TRUTHY
   var_dump([] && ""); //FALSY && FALSY
?>

• En la línea 2 se evaluaron ambos datos
• En la línea 3 se evaluaron ambos datos
• En la línea 4 solo se avaluó la primera
• En la línea 5 solo se evaluó la primera

Nuestro output

Un ejemplo más en php: 

<?php
   var_dump(5 || "pippo"); //TRUTHY && TRUTHY
   var_dump(true || 0);  //TRUTHY && FALSY
   var_dump("" || [12]); //FALSY && TRUTHY
   var_dump("" || 0); //FALSY && FALSY
?>

• En la línea 2 solo se evaluó la primera
• En la línea 3 solo se evaluó la primera
• En la línea 4 se evaluaron ambos datos
• En la línea 5 se evaluaron ambos datos

Nuestro output