Índice de contenido

La precedencia de los operadores en PHP sigue casi las mismas reglas que en matemáticas, por ejemplo: multiplicación y división preceden a suma y resta, los paréntesis fuerzan una precedencia, etc.

Cuando tienen la misma precedencia, su asociatividad decide cómo ordenar los operadores. Por ejemplo el operador suma + tiene asociatividad izquierda, por lo que la operación 1 + 2 + 3 sumará primero 1 y 2, y después 3 => (1 + 2) + 3. Por el contrario, el operador = tiene asociatividad derecha, por lo que $x = $y = $z se agrupa de forma $x = ($y = $z).

Los operadores de misma precedencia que no son asociativos no pueden usarse juntos, esto: 1 < 2 > 1 es incorrecto.

En ocasiones es aconsejable usar paréntesis aunque no sea necesario para mejorar la legibilidad.

La precedencia de operadores y su asociatividad sólo determinan cómo se agrupan las expresiones.

Lista de operadores ordenados por precedencia:

Los operadores aritméticos en PHP son los mismos que en las matemáticas:

*División devuelve un (int) si $x y $y son divisibles, o (float) si no lo son.

**En Módulo se eliminarían primero las partes decimales transformándose en (int) en caso de ser (float) y luego se haría la operación. El signo (+ o -) del resultado dependerá del dividendo, por ejemplo: -5 % 3 mostraría -2.

Existen operadores básicos y combinados:

El operador básico de asignación es "=", que actúa como definidor, no como igualador. El valor de una expresión de asignación es el valor que se le ha asignado, esto es: "$x = 3" tiene un valor de 3.

En el caso de arrays, se asigna un valor a una clave nombrada mediante el operador "=>".

Los operadores combinados permiten usar un valor en una expresión y establecer su nuevo valor como resultado de esa expresión:

<?php
$x = 3;
$x += 5;
// $x vale ahora 8

$y = "Hola ";
$y .= ", ¿Qué tal?";
// $y vale ahora "Hola, ¿Qué tal?"

Hay una excepción a la asignación por valor en PHP, y son los objetos, que se asignan por referencia. Los objetos se copian mediante la palabra clone.

La asignación por referencia significa que las variables apuntan a los mismos valores, sin hacer ninguna copia:

<?php
$x = 3;
$y = &$x;

print "$x, $y"; // Mostrará 3, 3

$x = 5;

print "$x, $y"; // Mostrará 5, 5

Las referencias actúan como cuando se crea un acceso directo o alias de un archivo o carpeta en el ordenador.

Los operadores bit a bit permiten la evaluación y manipulación de bits específicos dentro de un integer.

Los operadores de comparación permiten comparar dos valores. Estos valores dependen de los tipos que tengan asignados. Pueden verse las diferencias comparativas en la tabla de comparación de tipos.

Si se compara un número con un string o la comparación es entre strings numéricos, cada string se convierte en número y la comparación se realiza numéricamente (esto también se incluye con el uso de switch). Cuando se hacen comparaciones idénticas como === esto no tiene sentido ya que también se comparan los tipos.

<?php
var_dump(0 == "x"); // 0 == 0 true
var_dump("1" == "01"); // 1 == 1 true
var_dump("10" == "1y1"); // 10 == 10 true
var_dump(100 == "1e2"); // 100 == 100 true

switch ("x") {
case 0:
    echo "0";
    break;
case "x": // Nunca llegará porque "x" ya se ha encontrado con el caso "0"
    echo "x";
    break;
}

Cuando un string se evalúa en un contexto numérico, el valor y el tipo dependen de la conversión de string a números.

Comparaciones entre varios tipos:

Debido a la forma en que son interpretados internamente los floats, su comparación puede dar resultados inesperados, aunque existen formas de poder compararlos.

<?php
$x = "";
$accion = (empty($x)) ? 'valor1' : 'valor2'; // Devolverá (string) valor1

// Lo anterior será lo mismo que:
if(empty($x)) {
    $accion = 'valor1';
} else {
    $accion = 'valor2';
}

Supongamos la expresión $x ? $y : $z. Si $x es true, se evaluará $y. Si $x es false, se evaluará $z.

Una forma más reducida del operador ternario es mediante ?:. Suponiendo $x ?: $y, devolverá $x si $x es true, y $y si $x es false.

Cuando se antepone el símbolo de arroba @ ante cualquier expresión, cualquier mensaje de error que pueda generar esa expresión será ignorado.

Si track_errors está activado, el último error se guardará en la variable $php_errormsg y podrá emplearse.

<?php
$miArchivo = @file('archivo_que_no_existe') or
    die("No se ha podido abrir, el error ha sido '$php_errormsg'");

// Funciona también si por ejemplo se intenta acceder al key de un array que no existe:
$valor = @$array[$key]

@ Sólo funciona con expresiones (variables, llamadas a funciones o includes, constantes...) no funciona con definiciones de clases o funciones, condicionales como if o foreach...

El operador de ejecución `` hace que el contrenido entre las comillas invertidas se ejecute como comando de consola. Este operador es lo mismo que usar la functión shell_exec().

<?php
$var = `ls -al`; // Comando linux para mostrar un listado de archivos completo del directorio actual
echo "<pre>$var</pre>";

• Si safe_mode está activado o shell_exec() está desactivado, las comillas no funcionarán.
• Las comillas invertidas no significan nada cuando van dentro de comillas dobles.

Los operadores de incremento y decremento sólo afectan a números y strings, sin afectar a arrays, objects o resources. Decrementar un valor NULL no tiene efecto, pero si se incrementa se obtiene 1. Incrementar o decrementar booleanos no tiene efecto.

Ejemplo:

<?php
$x = 4;
echo "Esto es 4: " . $x++ . "</br>";
echo "Y esto es 5: " . $x . "</br>";

$x = 4;
echo "Esto es 5: " . ++$x . "</br>";
echo "Y esto es 5: " . $x . "</br>";

$x = 4;
echo "Esto es 4: " . $x-- . "</br>";
echo "Y esto es 3: " . $x . "</br>";

Al trabajar sobre caracteres, de Z pasa a AA. Por ejemplo:

<?php
$x = 'Z';
echo ++$x; // Devolverá AA
echo ++$x; // Devolverá AB

$x = 'A9';
echo ++$x; // Devolerá B0
echo ++$x; // Devolverá B1

$x = 'A09';
echo ++$x; // Devolverá A10
echo ++$x; // Devolverá A11

• && y || tienen precedencia sobre and y or.

Notas importantes:

<?php
$w = (false && foo()); // false
$x = (true  || foo()); // true
$y = (false and foo()); // false
$z = (true  or  foo()); // true

// Actúa como: ($m = (false || true))
$m = false || true;
// Actúa como: (($n = false) or true)
$n = false or true;

var_dump($m, $n);

// Actúa como: ($a = (true && false))
$a = true && false;
// Actúa como: (($b = true) and false)
$b = true and false;

var_dump($a, $b);

Existen dos operadores para strings:

• Operador de concatenación '.'. Concatena los argumentos derecho e izquierdo.
• Operador de asignación sobre concatenación '.=', añade el argumento del lado derecho al argumento del lado izquierdo.

<?php
$x = "Hola";
$y = $x . ", ¿Qué tal?"; // $y = "Hola, ¿Qué tal?"

$x = "Hola ";
$x .= ", ¿Qué tal?"; // $x = "Hola, ¿Qué tal?"

El operador + devuelve el array derecho ($y) añadido al del izquierdo ($x). Si hay keys que existen en ambas, se utilizarán las keys del array izquierdo.

Ejemplo de unión:

$a = array("x" => "perro", "y" => "gato");
$b = array("x" => "pato", "y" => "liebre", "z" => "conejo");
// Unión de $a y $b
$c = $a + $b;
echo "Unión de \$a y \$b: \n";
var_dump($c);
/*
* array (size=3)
  'x' => string 'perro' (length=5)
  'y' => string 'gato' (length=4)
  'z' => string 'conejo' (length=6)
*/
// Unión de $b y $a
$c = $b + $a;
echo "Union de \$b y \$a: \n";
var_dump($c);
/*
* array (size=3)
  'x' => string 'pato' (length=4)
  'y' => string 'liebre' (length=6)
  'z' => string 'conejo' (length=6)
*/

Ejemplo de comparación:

$x = array("perro", "gato");
$y = array(1 => "gato", "0" => "perro");

var_dump($x == $y); // bool(true)
var_dump($x === $y); // bool(false)

instanceof es utilizado para saber si una variable es un objeto instanciado de una clase.

class MiClase
{
}

class NoEsMiClase
{
}
$x = new MiClase;

var_dump($x instanceof MiClase); // true
var_dump($y instanceof NoEsMiClase); // false

• Devuelve true si la instancia es de una clase padre. instanceof PadreClass
• Devuelve true con la interface de una clase que la implementa. instanceof MyInterface
• Devuelve true si la variable es un string con el nombre de la clase: $c = 'MiClase'; instanceof $c
• Si la variable que está siendo comprobada no es un objeto, no devuelve error, devuelve false.