PHP
Los operadores

Introducción

Observaciones

Operadores de cadena (. Y. =)

Sólo hay dos operadores de cadena:

• Concatenación de dos cuerdas (punto):

  $a = "a";
  $b = "b";
  $c = $a . $b; // $c => "ab"
  

• Asignación de concatenación (punto =):

  $a = "a";
  $a .= "b"; // $a => "ab"
  

Asignación básica (=)

$a = "some string";

resulta en $a tener el valor de some string .

El resultado de una expresión de asignación es el valor que se asigna. Tenga en cuenta que un solo signo igual = NO es para comparación!

$a = 3;
$b = ($a = 5);

hace lo siguiente:

1. La línea 1 asigna 3 a $a .
2. La línea 2 asigna 5 a $a . Esta expresión también da valor 5 .
3. La línea 2 luego asigna el resultado de la expresión entre paréntesis ( 5 ) a $b .

Por lo tanto: tanto $a como $b ahora tienen valor 5 .

Asignación combinada (+ = etc)

Los operadores de asignación combinada son un atajo para una operación en alguna variable y posteriormente asignan este nuevo valor a esa variable.

Aritmética:

$a = 1;   // basic assignment
$a += 2; // read as '$a = $a + 2'; $a now is (1 + 2) => 3
$a -= 1; // $a now is (3 - 1) => 2
$a *= 2; // $a now is (2 * 2) => 4
$a /= 2; // $a now is (16 / 2) => 8
$a %= 5; // $a now is (8 % 5) => 3 (modulus or remainder)

// array +
$arrOne = array(1);
$arrTwo = array(2);
$arrOne += $arrTwo;

Procesando múltiples matrices juntos

$a **= 2; // $a now is (4 ** 2) => 16 (4 raised to the power of 2)

Concatenación combinada y asignación de una cadena:

$a = "a";
$a .= "b"; // $a => "ab"

Operadores de asignación bit a bit binaria combinados:

$a = 0b00101010;  // $a now is 42
$a &= 0b00001111; // $a now is (00101010 & 00001111) => 00001010 (bitwise and)
$a |= 0b00100010; // $a now is (00001010 | 00100010) => 00101010 (bitwise or)
$a ^= 0b10000010; // $a now is (00101010 ^ 10000010) => 10101000 (bitwise xor)
$a >>= 3;         // $a now is (10101000 >> 3) => 00010101 (shift right by 3)
$a <<= 1;         // $a now is (00010101 << 1) => 00101010 (shift left by 1)

Modificación de la precedencia del operador (entre paréntesis)

El orden en que se evalúan los operadores está determinado por la precedencia del operador (consulte también la sección Comentarios).

En

$a = 2 * 3 + 4;

$a obtiene un valor de 10 porque 2 * 3 se evalúa primero (la multiplicación tiene una precedencia más alta que la suma), lo que arroja un resultado secundario de 6 + 4 , que es igual a 10.

La precedencia se puede alterar utilizando paréntesis: en

$a = 2 * (3 + 4);

$a obtiene un valor de 14 porque (3 + 4) se evalúa primero.

Asociación

Asociación izquierda

Si la precedencia de dos operadores es igual, la asociatividad determina la agrupación (vea también la sección de Comentarios):

$a = 5 * 3 % 2; // $a now is (5 * 3) % 2 => (15 % 2) => 1

* y % tienen igual precedencia y asociatividad izquierda . Debido a que la multiplicación se produce primero (izquierda), se agrupa.

$a = 5 % 3 * 2; // $a now is (5 % 3) * 2 => (2 * 2) => 4

Ahora, el operador de módulo aparece primero (izquierda) y, por lo tanto, se agrupa.

Asociación correcta

$a = 1;
$b = 1;
$a = $b += 1;

Tanto $a como $b ahora tienen valor 2 porque $b += 1 se agrupa y luego el resultado ( $b es 2 ) se asigna a $a .

Operadores de comparación

Igualdad

Para las pruebas de igualdad básicas, se utiliza el operador igual == . Para verificaciones más completas, use el operador idéntico === .

El operador idéntico funciona igual que el operador igual, requiriendo que sus operandos tengan el mismo valor, pero también requiere que tengan el mismo tipo de datos.

Por ejemplo, la muestra a continuación mostrará 'a y b son iguales', pero no 'a y b son idénticos'.

$a = 4;
$b = '4';
if ($a == $b) {
    echo 'a and b are equal'; // this will be printed
}
if ($a === $b) {
    echo 'a and b are identical'; // this won't be printed
}

Cuando se usa el operador igual, las cadenas numéricas se convierten en enteros.

Comparacion de objetos

=== compara dos objetos al verificar si son exactamente la misma instancia . Esto significa que new stdClass() === new stdClass() resuelve en falso, incluso si se crean de la misma manera (y tienen exactamente los mismos valores).

== compara dos objetos verificando recursivamente si son iguales ( deep equals ). Eso significa que, para $a == $b , si $a y $b son:

1. de la misma clase
2. tienen el mismo conjunto de propiedades, incluidas las propiedades dinámicas
3. para cada propiedad $property establecida, $a->property == $b->property es verdadera (por lo tanto, verificada recursivamente).

Otros operadores de uso común

Incluyen:

1. Mayor que ( > )
2. Menor que ( < )
3. Mayor o igual que ( >= )
4. Menor o igual a ( <= )
5. No es igual a ( != )
6. No es idénticamente igual a ( !== )

1. Mayor que: $a > $b , devuelve true si $a 's valor es mayor que de $b , de lo contrario devuelve false.

Ejemplo :

var_dump(5 > 2); // prints bool(true)
var_dump(2 > 7); // prints bool(false)

2. Menor que: $a < $b , devuelve true si $a valor 's es más pequeña que la de $b , de lo contrario devuelve false.

Ejemplo :

var_dump(5 < 2); // prints bool(false)
var_dump(1 < 10); // prints bool(true)

3. Mayor o igual a : $a >= $b , devuelve true si el $a es mayor que $b o igual a $b , de lo contrario devuelve false .

Ejemplo :

var_dump(2 >= 2); // prints bool(true)
var_dump(6 >= 1); // prints bool(true)
var_dump(1 >= 7); // prints bool(false)

4. Menor o igual a : $a <= $b , devuelve true si el $a es menor que $b o igual a $b , de lo contrario devuelve false .

Ejemplo :

var_dump(5 <= 5); // prints bool(true)
var_dump(5 <= 8); // prints bool(true)
var_dump(9 <= 1); // prints bool(false)

5/6. No Igual / Idéntico Para: Para repetir el ejemplo anterior sobre igualdad, la muestra a continuación mostrará 'a y b no son idénticos', pero no 'a y b no son iguales'.

$a = 4;
$b = '4';
if ($a != $b) {
    echo 'a and b are not equal'; // this won't be printed
}
if ($a !== $b) {
    echo 'a and b are not identical'; // this will be printed
}

Operador de la nave espacial (<=>)

PHP 7 introduce un nuevo tipo de operador, que se puede utilizar para comparar expresiones. Este operador devolverá -1, 0 o 1 si la primera expresión es menor, igual o mayor que la segunda expresión.

// Integers
print (1 <=> 1); // 0
print (1 <=> 2); // -1
print (2 <=> 1); // 1

// Floats
print (1.5 <=> 1.5); // 0
print (1.5 <=> 2.5); // -1
print (2.5 <=> 1.5); // 1
 
// Strings
print ("a" <=> "a"); // 0
print ("a" <=> "b"); // -1
print ("b" <=> "a"); // 1

Los objetos no son comparables, y al hacerlo resultará en un comportamiento indefinido.

Este operador es particularmente útil al escribir una función de comparación definida por el usuario usando usort , uasort o uksort . Dada una matriz de objetos a clasificar por su propiedad de weight , por ejemplo, una función anónima puede usar <=> para devolver el valor esperado por las funciones de clasificación.

usort($list, function($a, $b) { return $a->weight <=> $b->weight; });

En PHP 5, esto habría requerido una expresión más elaborada.

usort($list, function($a, $b) {
    return $a->weight < $b->weight ? -1 : ($a->weight == $b->weight ? 0 : 1);
});

Operador coalescente nulo (??)

Null coalescing es un nuevo operador introducido en PHP 7. Este operador devuelve su primer operando si está establecido y no es NULL . De lo contrario devolverá su segundo operando.

El siguiente ejemplo:

$name = $_POST['name'] ?? 'nobody';

es equivalente a ambos:

if (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

y:

$name = isset($_POST['name']) ? $_POST['name'] : 'nobody'; 

Este operador también puede ser encadenado (con semántica asociativa a la derecha):

$name = $_GET['name'] ?? $_POST['name'] ?? 'nobody';

que es equivalente a:

if (isset($_GET['name'])) {
    $name = $_GET['name'];
} elseif (isset($_POST['name'])) {
    $name = $_POST['name'];
} else {
    $name = 'nobody';
}

Nota:
Al usar el operador coalescente en la concatenación de cadenas, no olvide usar paréntesis ()

$firstName = "John";
$lastName = "Doe";
echo $firstName ?? "Unknown" . " " . $lastName ?? "";

Esto generará solo a John , y si $ firstName es nulo y $ lastName es Doe , generará Unknown Doe . Para generar John Doe , debemos usar paréntesis como este.

$firstName = "John";
$lastName = "Doe";
echo ($firstName ?? "Unknown") . " " . ($lastName ?? "");

Esto dará salida a John Doe lugar de a John solamente.

instanceof (operador de tipo)

Para verificar si algún objeto es de una cierta clase, el operador de instanceof (binario) se puede usar desde la versión 5 de PHP.

El primer parámetro (izquierda) es el objeto a probar. Si esta variable no es un objeto, instanceof siempre devuelve false . Si se usa una expresión constante, se lanza un error.

El segundo parámetro (a la derecha) es la clase con la que se compara. La clase se puede proporcionar como el propio nombre de la clase, una variable de cadena que contiene el nombre de la clase (¡no una constante de cadena!) O un objeto de esa clase.

class MyClass {
}

$o1 = new MyClass();
$o2 = new MyClass();
$name = 'MyClass';

// in the cases below, $a gets boolean value true
$a = $o1 instanceof MyClass;
$a = $o1 instanceof $name;
$a = $o1 instanceof $o2;

// counter examples:
$b = 'b';
$a = $o1 instanceof 'MyClass'; // parse error: constant not allowed
$a = false instanceof MyClass; // fatal error: constant not allowed
$a = $b instanceof MyClass;    // false ($b is not an object)

instanceof también se puede usar para verificar si un objeto es de una clase que extiende otra clase o implementa alguna interfaz:

interface MyInterface {
}

class MySuperClass implements MyInterface {
}

class MySubClass extends MySuperClass {
}

$o = new MySubClass();

// in the cases below, $a gets boolean value true    
$a = $o instanceof MySubClass;
$a = $o instanceof MySuperClass;
$a = $o instanceof MyInterface;

Para verificar si un objeto no pertenece a alguna clase, se puede usar el operador no ( ! ):

class MyClass {
}

class OtherClass {
}

$o = new MyClass();
$a = !$o instanceof OtherClass; // true

Tenga en cuenta que los paréntesis alrededor de $o instanceof MyClass no son necesarios porque instanceof tiene mayor prioridad que ! , aunque puede hacer que el código sea más legible entre paréntesis.

Advertencias

Si una clase no existe, se llama a las funciones de carga automática registradas para tratar de definir la clase (¡este es un tema fuera del alcance de esta parte de la Documentación!). En las versiones de PHP anteriores a 5.1.0, el operador instanceof también activaría estas llamadas, definiendo así la clase (y si la clase no pudiera definirse, se produciría un error fatal). Para evitar esto, usa una cadena:

// only PHP versions before 5.1.0!
class MyClass {
}

$o = new MyClass();
$a = $o instanceof OtherClass; // OtherClass is not defined!
// if OtherClass can be defined in a registered autoloader, it is actually
// loaded and $a gets boolean value false ($o is not a OtherClass)
// if OtherClass can not be defined in a registered autoloader, a fatal
// error occurs.

$name = 'YetAnotherClass';
$a = $o instanceof $name; // YetAnotherClass is not defined!
// $a simply gets boolean value false, YetAnotherClass remains undefined.

A partir de la versión 5.1.0 de PHP, los autocargadores registrados ya no son llamados en estas situaciones.

Versiones anteriores de PHP (antes de 5.0)

En versiones anteriores de PHP (antes de 5.0), la función is_a se puede usar para determinar si un objeto es de alguna clase. Esta función está en desuso en la versión 5 de PHP y se desaprueba en la versión 5.3.0 de PHP.

Operador Ternario (? :)

El operador ternario puede considerarse como una instrucción if línea. Se compone de tres partes. El operator , y dos resultados. La sintaxis es la siguiente:

$value = <operator> ? <true value> : <false value>

Si el operator se evalúa como true , se devolverá el valor en el primer bloque ( <true value> ), de lo contrario, se devolverá el valor en el segundo bloque ( <false value> ). Dado que estamos configurando $value al resultado de nuestro operador ternario, almacenará el valor devuelto.

Ejemplo:

$action = empty($_POST['action']) ? 'default' : $_POST['action'];

$action contendría la cadena 'default' si empty($_POST['action']) evalúa como verdadera. De lo contrario, contendría el valor de $_POST['action'] .

La expresión (expr1) ? (expr2) : (expr3) evalúa a expr2 si expr1 evalúa como true , y expr3 si expr1 evalúa como false .

Es posible omitir la parte media del operador ternario. Expression expr1 ?: expr3 devuelve expr1 si expr1 evalúa como VERDADERO, y expr3 contrario. ?: se refiere a menudo como operador de Elvis .

Esto se comporta como el operador de unión nula ?? , excepto que ?? requiere que el operando izquierdo sea exactamente null mientras que ?: intenta resolver el operando izquierdo en un valor booleano y verifica si se resuelve en false booleano.

Ejemplo:

function setWidth(int $width = 0){
    $_SESSION["width"] = $width ?: getDefaultWidth();
}

En este ejemplo, setWidth acepta un parámetro de ancho, o 0 predeterminado, para cambiar el valor de la sesión de ancho. Si $width es 0 (si $width no se proporciona), que se resolverá en booleano falso, en su lugar se usa el valor de getDefaultWidth() . La función getDefaultWidth() no se llamará si $width no se resolvió como booleano falso.

Consulte Tipos para obtener más información sobre la conversión de variables a booleano.

Incremento (++) y operadores decrecientes (-)

Las variables se pueden incrementar o disminuir en 1 con ++ o -- , respectivamente. Pueden preceder o tener éxito en las variables y variar ligeramente de forma semántica, como se muestra a continuación.

$i = 1;
echo $i; // Prints 1

// Pre-increment operator increments $i by one, then returns $i
echo ++$i; // Prints 2

// Pre-decrement operator decrements $i by one, then returns $i
echo --$i; // Prints 1

// Post-increment operator returns $i, then increments $i by one
echo $i++; // Prints 1 (but $i value is now 2)

// Post-decrement operator returns $i, then decrements $i by one
echo $i--; // Prints 2 (but $i value is now 1)

Se puede encontrar más información sobre el incremento y la disminución de los operadores en la documentación oficial .

Operador de Ejecución (``)

El operador de ejecución de PHP consta de backticks (``) y se utiliza para ejecutar comandos de shell. La salida del comando se devolverá y, por lo tanto, se puede almacenar en una variable.

// List files
$output = `ls`;
echo "<pre>$output</pre>";

Tenga en cuenta que el operador de ejecución y shell_exec() darán el mismo resultado.

Operadores lógicos (&& / AND y || / OR)

En PHP, hay dos versiones de operadores lógicos AND y OR.

Tenga en cuenta que el && y || Los operadores tienen mayor prioridad que and y or . Vea la tabla de abajo:

Debido a esto, es más seguro usar && y || en lugar de and y or .

Operadores de Bitwise

Prefijo de operadores bitwise

Los operadores bitwise son como operadores lógicos, pero se ejecutan por bit en lugar de por valor booleano.

// bitwise NOT ~: sets all unset bits and unsets all set bits
printf("%'06b", ~0b110110); // 001001

Operadores de máscara de bits

Bitwise AND & : un bit se establece solo si se establece en ambos operandos

printf("%'06b", 0b110101 & 0b011001); // 010001

Bitwise o | : se establece un bit si se establece en uno o ambos operandos

printf("%'06b", 0b110101 | 0b011001); // 111101

Bitwise XOR ^ : se establece un bit si se establece en un operando y no se establece en otro operando, es decir, solo si ese bit está en un estado diferente en los dos operandos

printf("%'06b", 0b110101 ^ 0b011001); // 101100

Ejemplos de usos de las máscaras de bits.

Estos operadores pueden ser utilizados para manipular las máscaras de bits. Por ejemplo:

file_put_contents("file.log", LOCK_EX | FILE_APPEND);

Aquí, el | El operador se utiliza para combinar las dos máscaras de bits. Aunque + tiene el mismo efecto, | hace hincapié en que está combinando máscaras de bits, no agregando dos enteros escalares normales.

class Foo{
    const OPTION_A = 1;
    const OPTION_B = 2;
    const OPTION_C = 4;
    const OPTION_A = 8;

    private $options = self::OPTION_A | self::OPTION_C;

    public function toggleOption(int $option){
        $this->options ^= $option;
    }

    public function enable(int $option){
        $this->options |= $option; // enable $option regardless of its original state
    }

    public function disable(int $option){
        $this->options &= ~$option; // disable $option regardless of its original state,
                                    // without affecting other bits
    }

    /** returns whether at least one of the options is enabled */
    public function isOneEnabled(int $options) : bool{
        return $this->options & $option !== 0;
        // Use !== rather than >, because 
        // if $options is about a high bit, we may be handling a negative integer
    }

    /** returns whether all of the options are enabled */
    public function areAllEnabled(int $options) : bool{
        return ($this->options & $options) === $options;
        // note the parentheses; beware the operator precedence
    }
}

Este ejemplo (asumiendo que la $option solo contiene un bit) utiliza:

• El operador ^ para alternar convenientemente las máscaras de bits.
• el | operador para establecer un bit descuidando su estado original u otros bits
• el operador ~ para convertir un entero con solo un bit establecido en un entero con solo un bit no establecido
• El operador & para desactivar un poco, usando estas propiedades de & :
  • Dado que &= con un bit establecido no hará nada ( (1 & 1) === 1 , (0 & 1) === 0 ), haciendo &= con un entero con un solo bit no establecido solo se eliminará ese bit , no afectando a otros bits.
  • &= con un bit no establecido, este bit ( (1 & 0) === 0 , (0 & 0) === 0 )
• El uso del operador & con otra máscara de bits filtrará todos los demás bits que no estén definidos en esa máscara de bits.
  • Si la salida tiene algún bit establecido, significa que cualquiera de las opciones está habilitada.
  • Si la salida tiene todos los bits de la máscara de bits establecida, significa que todas las opciones de la máscara de bits están habilitadas.

Tenga en cuenta que estos operadores de comparación: ( < > <= >= == === != !== <> <=> ) tienen mayor prioridad que estos operadores máscara de bits de máscara de bits-: ( | ^ & ). Dado que los resultados a nivel de bits se comparan a menudo utilizando estos operadores de comparación, este es un error común que se debe tener en cuenta.

Operadores de cambio de bits

Bitwise left shift << : desplaza todos los bits a la izquierda (más importante) según el número de pasos dado y descarta los bits que excedan el tamaño int

<< $x es equivalente a eliminar los $x bits más altos y multiplicar por la potencia de $x th de 2

printf("%'08b", 0b00001011<< 2); // 00101100

assert(PHP_INT_SIZE === 4); // a 32-bit system
printf("%x, %x", 0x5FFFFFFF << 2, 0x1FFFFFFF << 4); // 7FFFFFFC, FFFFFFFF

Desplazamiento a la derecha a nivel de bit >> : descarte el desplazamiento más bajo y desplace los bits restantes a la derecha (menos significativo)

>> $x es equivalente a dividir por la potencia de $x th de 2 y descartar la parte no entera

printf("%x", 0xFFFFFFFF >> 3); // 1FFFFFFF

Ejemplos de usos del desplazamiento de bits:

División rápida por 16 (mejor rendimiento que /= 16 )

$x >>= 4;

En los sistemas de 32 bits, esto descarta todos los bits en el entero, estableciendo el valor en 0. En los sistemas de 64 bits, esto desactiva los 32 bits más significativos y mantiene el menor

$x = $x << 32 >> 32;

32 bits significativos, equivalentes a $x & 0xFFFFFFFF

Nota: En este ejemplo, se usa printf("%'06b") . Da salida al valor en 6 dígitos binarios.

Operadores de objetos y clases

Se puede acceder a los miembros de objetos o clases utilizando el operador de objeto ( -> ) y el operador de clase ( :: .

class MyClass {
    public $a = 1;
    public static $b = 2;
    const C = 3;
    public function d() { return 4; }
    public static function e() { return 5; }
}

$object = new MyClass();
var_dump($object->a);   // int(1)
var_dump($object::$b);  // int(2)
var_dump($object::C);   // int(3)
var_dump(MyClass::$b);  // int(2)
var_dump(MyClass::C);   // int(3)
var_dump($object->d()); // int(4)
var_dump($object::d()); // int(4)
var_dump(MyClass::e()); // int(5)
$classname = "MyClass";
var_dump($classname::e()); // also works! int(5)

Tenga en cuenta que después del operador del objeto, $ no debe escribirse ( $object->a lugar de $object->$a ). Para el operador de la clase, este no es el caso y el $ es necesario. Para una constante definida en la clase, el $ nunca se usa.

También tenga en cuenta que var_dump(MyClass::d()); sólo se permite si la función d() no hace referencia al objeto:

class MyClass {
    private $a = 1;
    public function d() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump(MyClass::d());   // Error!

Esto provoca un 'Error fatal de PHP: error no detectado: usar $ esto cuando no está en el contexto del objeto'

Estos operadores han dejado asociatividad, que se puede utilizar para el "encadenamiento":

class MyClass {
    private $a = 1;
    
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    
    public function get() {
        return $this->a;
    }
}

$object = new MyClass();
var_dump($object->add(4)->get());  // int(5)

Estos operadores tienen la mayor prioridad (ni siquiera se mencionan en el manual), incluso más que el clone . Así:

class MyClass {
    private $a = 0;
    public function add(int $a) {
        $this->a += $a;
        return $this;
    }
    public function get() {
        return $this->a;
    }
}

$o1 = new MyClass();
$o2 = clone $o1->add(2);
var_dump($o1->get()); // int(2)
var_dump($o2->get()); // int(2)

El valor de $o1 se agrega a antes de clonar el objeto.

Tenga en cuenta que el uso de paréntesis para influir en la prioridad no funcionó en la versión 5 de PHP y anteriores (lo hace en PHP 7):

// using the class MyClass from the previous code
$o1 = new MyClass();
$o2 = (clone $o1)->add(2);  // Error in PHP 5 and before, fine in PHP 7
var_dump($o1->get()); // int(0) in PHP 7
var_dump($o2->get()); // int(2) in PHP 7