Neuralpin Logo

Operadores en PHP

Existen operadores para diferentes tipos de datos; operadores para valores numéricos que facilitan cálculos matemáticos básicos, operadores para gestión de texto, operadores lógicos y de comparación que son cruciales para la toma de decisiones, etc

Operadores en PHP

Los operadores son la herramienta más básica para manipular datos y gestionar el flujo de un programa, a continuación estudiaremos gran parte de ellos.

Operadores Aritméticos

Los operadores aritméticos en PHP permiten realizar operaciones matemáticas básicas sobre valores numéricos y son los siguientes:

  • Suma (+): Suma dos números.
  • Resta (-): Resta un número de otro.
  • Multiplicación (*): Multiplica dos números.
  • División (/): Divide un número entre otro.
  • Potenciación (**): Eleva a un número a la potencia indicada por otro número.
  • Módulo (%): Devuelve el residuo de una división.

Ejemplo de uso de los operadores aritméticos:

$a = 10;
$b = 3;

echo $a + $b;  // 10 + 3 = 13
echo $a - $b;  // 10 - 3 = 7
echo $a * $b;  // 10 * 3 = 30
echo $a / $b;  // 10 / 3 = 3.3333
echo $a ** $b;  // 10**3 = 1000
echo $a % $b;  // 10 % 3 = 1 (Diez dividido entre tres es igual a 3 y resta 1)

Operadores de Asignación

Los operadores de asignación se utilizan para asignar valores a las variables y ya vimos el operador de asignación más básico, el signo "igual que" (=), pero en PHP este operador se puede combinar con los operadores aritméticos para realizar alguna operación matemática y en automático asignar el resultado a una variable.

  • Asignación simple (=) Asigna un valor a una variable.
  • Adición y asignación (+=) Suma y asigna el resultado, es equivalente a $a = $a + 5.
  • Sustracción y asignación (-=) Resta y asigna el resultado. Es equivalente a $a = $a - 3.
  • Multiplicación y asignación (*=) Multiplica y asigna el resultado. Es equivalente a $a = $a * 2.
  • División y asignación (/=) Divide y asigna el resultado. Equivalente a $a = $a / 4.
  • Potenciación y asignación (**=) Eleva y asigna el [resultado. Es](http://resultado.Es) equivalente a $a = $a ** 3.
  • Modulo y asignación (%=) Divide y asigna el residuo resultante. Es equivalente a $a = $a % 3

Estos operadores de asignación hacen que el código sea más conciso y fácil de leer, veamos un ejemplo:

También tenemos los operadores abreviados para incremento y decremento, estos operadores permiten de una forma resumida sumar o restar una unidad a un número e inmediatamente asignar el resultado a la variable.

Los operadores serían los siguientes:

  • $a++ Suma uno a una variable. Equivalente a: $a = $a + 1.
  • $a-- Resta uno a una variable. Equivalente a: $a = $a -1
$a = 5;

$a++;  // $a es ahora 6
$a--;  // $a vuelve a valer 5

Operadores para cadenas de texto

PHP tiene solo dos operadores para texto, uno permite unir cadenas (concatenación) y el otro permite de forma abreviada unir una cadena a una variable previa y asignar el resultado final.

  • Concatenación (.) Une dos cadenas de texto.
  • Concatenación y asignación (.=) Une una cadena a otra cadena previamente definida y asigna el resultado.

Ejemplo:

$message = 'Hola';
$user = 'Luis';

echo $message . ' ' . $user; // Hola Luis

$message .= ' ' . $user;
echo $message; // Hola Luis

Hay que notar que por cada cadena de texto que se quiere concatenar también se concatena un espacio para que las palabras no queden juntas.

Hay otra forma de concatenar cadenas y otros valores sin el operador punto:

echo "{$message} {$user}"; // Hola Luis

Para usar este método es necesario usar comillas simples, y luego entre llaves se indica el valor a concatenar.

Se puede concatenar cualquier valor aunque no sea una cadena de texto siempre y cuando sea un escalar, pero hay que tener en cuenta que ese valor sera convertido a texto de forma dinámica y que hay que tener cuidado con valores booleanos o nulos.

Al intentar imprimir un valor booleano verdadero este sera convertido a 1, pero al intentar imprimir un valor falso o el valor null, estos no imprimirán nada.

Operadores de comparación y operadores lógicos

Estos operadores nos permitirán crear programas que puedan tomar decisiones en base a los valores que proporcionemos y controlar el flujo de los datos hacia los algoritmos correspondientes y ejecutar solo las instrucciones correspondientes.

Operadores de Comparación

Estos operadores se utilizan para comparar dos valores y nos da como resultado un valor que puede ser verdadero ó falso, los operadores son los siguientes:

  • Equivalente (==) Verifica si dos valores son equivalentes.
  • Idéntico (===) Verifica si dos valores son iguales y del mismo tipo.
  • Diferente (!= o <>) Verifica si dos valores son diferentes.
  • No idéntico (!==) Verifica si dos valores no son iguales o no son del mismo tipo.
  • Mayor que (>) Verifica si un valor es mayor que otro.
  • Menor que (<) Verifica si un valor es menor que otro.
  • Mayor o igual que (>=) Verifica si un valor es mayor o igual que otro.
  • Menor o igual que (<=) Verifica si un valor es menor o igual que otro.

Ejemplo:

$a = 5;
$b = 10;

var_dump( $a == $b );  // Cinco es igual a diez? Falso
var_dump( $a === $b ); // Cinco es igual a diez y del mismo tipo? Falso
var_dump( $a != $b );  // Cinco es diferente de 10? Verdadero
var_dump( $a !== $b ); // Cinco es diferente de 10 ó de diferente tipo? Verdadero
var_dump( $a > $b );   // Cinco es mayor que diez? Falso
var_dump( $a < $b );   // Cinco es menor que diez? Verdadero
var_dump( $a >= $b );  // Cinco es mayor o igual que diez? Falso
var_dump( $a <= $b );  // Cinco es menor o igual que diez? verdadero

var_dump() es una herramienta que nos de PHP para depurar (identificar y corregir problemas, en ingles se le conoce como "debugging"), permite imprimir el tipo y valor de un dato o una variable, solo es necesario escribir var_dump y entre paréntesis escribir el valor a inspeccionar.

Operadores Lógicos

Los operadores lógicos se utilizan para combinar datos booleanos y dependiendo de los valores previos y el tipo de operador usado darán como resultado un valor verdadero o falso.

  • And (&&) Verdadero si ambas declaraciones son verdaderas.
  • Or (||) Verdadero si al menos una de las declaraciones es verdadera.
  • Or Excluyente (XOR) Verdadero si solo una de las dos declaraciones es verdadera.

Ejemplo:

$a = true;
$b = false;

var_dump($a && $b);  // bool(false)
var_dump($a || $b);  // bool(true)
var_dump($a XOR $b);  // bool(true)

Operador lógico de negación

  • Negación (!): Invierte un valor booleano, la declaración será verdadera solo si el valor previo era falso.

Ejemplo:

$a = true;
$b = false;

var_dump(!$a);       // bool(false)
var_dump(!$b);       // bool(true)

Si el valor previo a ser negado no era booleano este será convertido a booleano y luego será negado, ejemplo:

$a = '';
$b = 5;
$c = 0;
$d = 'Hola';
$e = null;
$f = -1;

var_dump(!$a);       // bool(true)
var_dump(!$b);       // bool(false)
var_dump(!$c);       // bool(true)
var_dump(!$d);       // bool(false)
var_dump(!$e);       // bool(true)
var_dump(!$f);       // bool(false)

Los valores que sean considerados vacíos serán evaluados como el valor booleano false.

Entre estos valores vacíos podemos encontrar

  • el número cero (0)
  • una cadena de texto vacía ('')
  • el valor nulo (null)
  • un arreglo de datos vació ([])

Cualquier otro valor será evaluado como verdadero, por lo que hay que tener cuidado, ya que incluso los valores numéricos negativos serán evaluados como verdaderos.

El operador de negación puede ser usado dos veces en el mismo valor, y lo que básicamente hará esta operación, sera convertir cualquier valor de cualquier otro tipo en un valor booleano y si el valor ya era booleano este se mantendrá intacto.

Ejemplo:

$a = '';
$b = true;

var_dump(!!$a);       // bool(false)
var_dump(!!$b);       // bool(true)

Operador de fusión de nulos

El operador de fusión de nulos (Nullish coalescense operator "??" ) funciona con al menos dos valores y permite evaluar si el primer valor dado es nulo, en caso de que no sea nulo, retornara ese valor, en caso de que el primer valor sea nulo, el operador retornara el segundo dato, sea cual sea su valor.

Ejemplo:

$message = null;
$defaultMessage = 'Buenos días';

echo $message ?? $defaultMessage; // Buenos días

Este operador incluso variables que no existan (evaluándolas como el valor nulo), por lo que es muy útil para comprobar datos y asignar valores por defecto. Por ejemplo:

$message = $message ?? 'Buenos días';

echo $message; // Buenos días

En este ejemplo la variable $message no existe previamente, por lo que usando el operador ?? podemos definir un valor por defecto, y cuando la variable si exista, pues en ese caso sera su valor el que se asignara.

Este operador también cuenta con su forma abreviada de asignación, por lo que el código anterior puede quedar de la siguiente manera:

$message ??= 'Buenos días';
echo $message; // Buenos días

Este operador se puede usar mas de una vez en la misma sentencia, permitiendo evaluar múltiples datos, hasta encontrar alguno que no sea nulo para retornarlo, o de lo contrario retornara el ultimo valor dado, ejemplo:

$messageDefault = 'Buenos días';
echo $message1 ?? $message2 ?? $message3 ?? $messageDefault; // Buenos días

El operador ternario y el operador Elvis

Este operador es similar al anterior, pero solo funciona con variables definidas, acepta hasta 3 datos, uno para evaluar y uno o dos valores para ser retornados.

El operador ternario evalúa si el primer valor dado es verdadero o falso, si es verdadero se retornará el primer valor disponible para su retorno, caso contrario se retorna el ultimo valor disponible, por ejemplo:

$age = 12;
$message = $age < 18 ? 'Eres menor de edad' : 'Eres mayor de edad';

En este ejemplo:

  • Se declara una variable $age y se le asigna el valor 12
  • Se utiliza el operador ternario para evaluar si $age es menor que 18
  • Si la condición es verdadera, se asigna el mensaje 'Eres menor de edad' a la variable $message. Si es falsa, se asigna 'Eres mayor de edad'

El operador ternario tiene su forma abreviada en la que solo funciona con dos datos y se utiliza para evaluar un valor y si es verdadero ese valor es retornado directamente, caso contrario se retorna el segundo valor, ejemplo:

$username = ''; // Aún no se ha definido un nombre de usario
$message = $username ?: 'Usuario Anónimo';

echo $message; // Imprime Usuario Anónimo

El operador ternario en su forma abreviada se conoce como el Operador Elvis y simplifica el código a la hora de asignar valores por defecto, lo que lo vuelve muy parecido al operador de fusión de nulos solo que en esta caso solo evaluamos si el valor es verdadero o falso.

Conclusión:

Hasta aquí esta introducción a los diversos operadores disponibles en PHP, que son fundamentales para manipular datos y controlar el flujo de tu programa.

Cada operador tiene su propósito especifico, gran parte de estos serán usados en tu día a día como programador mientras que otros se emplearán unicamente en casos especiales.

Ulises Rendón

Desarrollador de Software

Es un programador apasionado por la ciencia y la tecnología, vive en la ciudad de México y fundó Neuralpin con el objetivo de divulgar conocimiento sobre tecnología y desarrollo.

Ver más sobre el autor