Operadores aritméticos, lógicos y relacionales

Los operadores en PHP son símbolos que permiten realizar operaciones sobre variables y valores. Los operadores se clasifican en aritméticos, lógicos y relacionales, y son fundamentales para construir expresiones y controlar el flujo del programa.

Los operadores aritméticos se utilizan para realizar operaciones matemáticas básicas. Por ejemplo, el operador de suma (+) permite agregar dos valores numéricos:

$a = 10;
$b = 5;
$resultado = $a + $b; // $resultado es 15

Además de la suma, PHP ofrece operadores para resta (-), multiplicación (*), división (/), módulo (%) y exponenciación (**). El operador de módulo devuelve el resto de la división entre dos números:

$resto = $a % $b; // $resto es 0 porque 10 es divisible por 5

Los operadores lógicos se emplean para combinar expresiones booleanas y tomar decisiones basadas en múltiples condiciones. Los operadores lógicos principales son && (AND), || (OR) y ! (NOT). Por ejemplo, para verificar si un número es mayor que cero y menor que diez:

$numero = 7;
$esValido = ($numero > 0) && ($numero < 10); // $esValido es true

El operador && devuelve true solo si ambas condiciones son verdaderas. El operador || devuelve true si al menos una de las condiciones es verdadera:

$esValido = ($numero < 0) || ($numero > 100); // $esValido es false

Para poder mostrar el resultado de un booleano, ya sea por terminal o en la página del servidor donde lanzamos la aplicación de PHP, utilizamos la función var_export($esValido), ya que al hacer echo de manera normal, si el valor del booleano es True, no muestra ningún valor en pantalla, en cambio con la función var_export, puedes ver el valor que tiene el booleano:

echo $esValido; // Como resultado mostrará: "" si es True o "1" si es False

var_export($esValidoOR); // Como resultado mostrará: "True" o "False" dependiendo de la expresión

Los operadores relacionales permiten comparar valores y determinar la relación entre ellos. Los operadores más comunes son == (igual a), != (distinto de), > (mayor que), < (menor que), >= (mayor o igual que) y <= (menor o igual que):

$a = 5;
$b = 3;
$esMayor = $a > $b; // $esMayor es true

Es importante distinguir entre == y ===. El operador == verifica si dos valores son iguales después de la conversión de tipos, mientras que === comprueba si son iguales y del mismo tipo:

$valor1 = 5;        // entero
$valor2 = '5';      // cadena
$comparacion1 = $valor1 == $valor2;  // true
$comparacion2 = $valor1 === $valor2; // false

El operador de nave espacial (<=>) es una adición útil que permite comparar dos expresiones en una sola operación. Devuelve -1 si el primer operando es menor, 0 si son iguales y 1 si es mayor:

$resultado = $a <=> $b; // $resultado es 1 porque $a es mayor que $b

Al combinar operadores, es crucial tener en cuenta la precedencia y el uso de paréntesis para garantizar que las expresiones se evalúen en el orden deseado. Por ejemplo:

$valor = 5 + 3 * 2;    // $valor es 11
$valor = (5 + 3) * 2;  // $valor es 16

Los operadores de asignación combinados permiten simplificar el código al realizar una operación y asignar el resultado en una sola expresión. Por ejemplo, para incrementar una variable:

$contador = 0;
$contador += 1; // Equivalente a $contador = $contador + 1;

Finalmente, los operadores de incremento (++) y decremento (--) modifican el valor de una variable numérica en uno. Pueden utilizarse en forma prefija o postfija, lo que afecta el momento en que se realiza la operación:

$a = 5;
$b = ++$a; // $a es 6, $b es 6
$c = $a--; // $a es 5, $c es 6

Comprender el uso correcto de los operadores aritméticos, lógicos y relacionales es esencial para construir algoritmos eficientes y escribir código claro en PHP.

Precedencia y asociatividad de operadores

La precedencia de operadores en PHP determina el orden en que las operaciones son evaluadas en una expresión. Los operadores con mayor precedencia se evaluarán antes que aquellos con menor precedencia. Por otro lado, la asociatividad define cómo se agrupan los operadores de igual precedencia: si se evalúan de izquierda a derecha (asociatividad izquierda) o de derecha a izquierda (asociatividad derecha).

Por ejemplo, en la expresión:

$resultado = 5 + 3 * 2;

El operador de multiplicación (*) tiene mayor precedencia que el operador de suma (+), por lo que la multiplicación se evaluará primero. Así, $resultado será igual a 11 y no a 16. Para alterar el orden de evaluación, se pueden utilizar paréntesis:

$resultado = (5 + 3) * 2; // Ahora $resultado es 16

Los paréntesis tienen la precedencia más alta y se utilizan para agrupar expresiones y controlar el orden de evaluación. Esto es especialmente útil cuando se desea asegurarse de que ciertas operaciones se realicen antes que otras, independientemente de la precedencia natural de los operadores involucrados.

La asociatividad de operadores es relevante cuando en una expresión aparecen varios operadores con la misma precedencia. Por ejemplo, los operadores de asignación tienen asociatividad de derecha a izquierda:

$a = $b = $c = 10;

En este caso, la asignación se realiza comenzando desde la derecha. Primero, $c se asigna el valor 10, luego $b se asigna el valor de $c, y finalmente $a se asigna el valor de $b. Como resultado, las tres variables tendrán el valor 10.

Por otro lado, los operadores aritméticos como suma (+) y resta (-) tienen asociatividad izquierda. En la expresión:

$resultado = 20 - 5 - 5;

La operación se evalúa desde la izquierda: primero 20 - 5 es 15, y luego 15 - 5 es 10. Si la asociatividad fuera derecha, el resultado sería diferente.

Conocer la tabla de precedencia de operadores en PHP es esencial para evitar errores lógicos. A continuación, se muestran algunos operadores comunes ordenados de mayor a menor precedencia:

1. clone, new
2. [ ], (), ->, ::, **, (int), (float), etc.
3. ++, --, ~, ! (operadores unarios)
4. ** (exponenciación)
5. *, /, % (multiplicación, división y módulo)
6. +, -, . (suma, resta y concatenación)
7. <<, >> (desplazamiento de bits)
8. <, >, <=, >=, instanceof, <> (comparaciones)
9. ==, !=, ===, !== (igualdad y identidad)
10. & (AND bit a bit)
11. ^ (XOR bit a bit)
12. | (OR bit a bit)
13. && (AND lógico)
14. || (OR lógico)
15. ?? (operador de fusión de null)
16. ? : (operador ternario)
17. = (asignación) y sus variantes +=, -=, *=, etc.

Al combinar operadores lógicos, la precedencia también es crucial. El operador && tiene mayor precedencia que ||, por lo que en la siguiente expresión:

$valor = true || false && false;

Se evalúa como true || (false && false). Primero, false && false es false, luego true || false es true. Si se desea cambiar el orden de evaluación, se deben usar paréntesis:

$valor = (true || false) && false; // $valor es false

Cuando se trabaja con expresiones complejas, es una buena práctica utilizar paréntesis para hacer el código más claro y evitar ambigüedades. Aunque se conozca la precedencia y asociatividad, el uso explícito de paréntesis mejora la legibilidad y mantenimiento del código.

Conversión y casting de tipos

En PHP, es común trabajar con diferentes tipos de datos, y en ocasiones es necesario convertir un valor de un tipo a otro. Esta conversión de tipos puede ser implícita o explícita, y es fundamental entender cómo funciona para evitar comportamientos inesperados en el código.

La conversión implícita ocurre cuando PHP cambia automáticamente el tipo de una variable según el contexto en el que se utiliza. Por ejemplo, al sumar una cadena que contiene un número con un entero:

$cadena = "10";
$entero = 5;
$suma = $cadena + $entero; // $suma será 15

En este caso, PHP convierte la cadena "10" a un entero para poder realizar la operación aritmética. Aunque este comportamiento puede ser útil, es importante ser consciente de él para prevenir errores lógicos.

La conversión explícita, también conocida como casting, permite forzar a una variable a adoptar un tipo específico. Esto se logra utilizando operadores de casting antes del valor o variable a convertir. Los tipos de casting más comunes en PHP son (int), (float), (string), (bool), (array) y (object).

Por ejemplo, para convertir una cadena a un entero:

$cadena = "42";
$entero = (int)$cadena; // $entero es 42 como entero

Al convertir valores a booleanos, es importante conocer qué valores se consideran false. En PHP, los siguientes valores son evaluados como false: false, 0, 0.0, "", "0", [], null y tipos similares. Cualquier otro valor se considera true:

$valor = 0;
$booleano = (bool)$valor; // $booleano es false

$valor = "PHP";
$booleano = (bool)$valor; // $booleano es true

Además de los operadores de casting, existen funciones como intval(), floatval(), strval() y boolval() que permiten realizar conversiones de forma más explícita y, en algunos casos, con mayor control:

$cadena = "3.14";
$entero = intval($cadena);     // $entero es 3
$flotante = floatval($cadena); // $flotante es 3.14

Es relevante considerar que al realizar conversiones puede haber pérdida de precisión o información. Por ejemplo, al convertir un número de punto flotante a entero, se elimina la parte decimal:

$numero = 7.9;
$entero = (int)$numero; // $entero es 7

Desde PHP 7, es posible utilizar tipado estricto para reforzar el control sobre los tipos de datos. Al declarar declare(strict_types=1); al inicio del script, se exige que los tipos coincidann exactamente, evitando conversiones implícitas en funciones y métodos:

declare(strict_types=1);

function multiplicar(int $a, int $b): int {
    return $a * $b;
}

$resultado = multiplicar("4", 5); // Genera un TypeError

En este ejemplo, sin el tipado estricto, PHP convertiría la cadena "4" a entero y no habría error. Con el modo estricto activado, se produce un TypeError porque se espera un entero y se ha proporcionado una cadena.

Al comparar valores, es crucial entender la diferencia entre los operadores == (igualdad) y === (identidad). El operador == compara los valores después de realizar conversiones de tipos si es necesario, mientras que === compara tanto el valor como el tipo, sin realizar conversiones:

$a = 0;
$b = "0";

$esIgual = ($a == $b);    // true, porque ambos valores son considerados iguales
$esIdentico = ($a === $b); // false, porque los tipos difieren (int vs string)

Para evitar comportamientos inesperados, especialmente en condiciones, es recomendable utilizar el operador de identidad === y ser explícito en las conversiones.

También es posible convertir arrays a otros tipos. Al convertir un array a un objeto, cada elemento se convierte en una propiedad pública del objeto:

$datos = ['nombre' => 'María', 'edad' => 28];
$objeto = (object)$datos;

echo $objeto->nombre; // Muestra 'María'

Sin embargo, convertir un array a una cadena no produce un resultado útil, ya que simplemente devuelve la palabra "Array". Para obtener una representación en cadena del array, es preferible usar funciones como implode() o json_encode():

$frutas = ['manzana', 'pera', 'uva'];
$cadena = implode(', ', $frutas);    // $cadena es 'manzana, pera, uva'
$json = json_encode($frutas);        // $json es '["manzana","pera","uva"]'

Al manipular datos, es esencial entender cómo PHP maneja la conversión y casting de tipos para escribir código seguro y eficiente. Ser explícito en las conversiones y utilizar las herramientas que ofrece el lenguaje ayuda a prevenir errores y a mantener la integridad de los datos en las aplicaciones.