operators =& - Referencia-¿Qué significa este símbolo en PHP?




que para (15)

Pregunta :

¿Qué significa "&" aquí en PHP?

Operador PHP "&"

Hace la vida más fácil una vez que nos acostumbramos a ella (ver el ejemplo a continuación con cuidado)

Y usualmente se comprueban los bits que están establecidos tanto en $ a como en $ b.

¿Te has dado cuenta de cómo funcionan estas llamadas?

   error_reporting(E_ERROR | E_WARNING | E_PARSE);
    error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);
    error_reporting(E_ALL & ~E_NOTICE);
    error_reporting(E_ALL);

Así que detrás de todo lo anterior está el juego de bit a bit y el operador.

Un caso útil de estos son las configuraciones fáciles, como las que aparecen a continuación, por lo que un solo campo entero puede almacenar miles de combos para usted.

La mayoría de las personas ya han leído los documentos, pero no han confiado el caso de uso en el mundo real de estos operadores de bitwise.

Ejemplo que te encantará

<?php

class Config {

    // our constants must be 1,2,4,8,16,32,64 ....so on
    const TYPE_CAT=1;
    const TYPE_DOG=2;
    const TYPE_LION=4;
    const TYPE_RAT=8;
    const TYPE_BIRD=16;
    const TYPE_ALL=31;

    private $config;

    public function __construct($config){
        $this->config=$config;

        if($this->is(Config::TYPE_CAT)){
            echo 'cat ';
        }
        if($this->is(Config::TYPE_DOG)){
            echo 'dog ';
        }
        if($this->is(Config::TYPE_RAT)){
            echo 'rat ';
        }
        if($this->is(Config::TYPE_LION)){
            echo 'lion ';
        }
        if($this->is(Config::TYPE_BIRD)){
            echo 'bird ';
        }
        echo "\n";
    }

    private function is($value){
        return $this->config & $value;
    }
}

new Config(Config::TYPE_ALL);
// cat dog rat lion bird
new Config(Config::TYPE_BIRD);
//bird
new Config(Config::TYPE_BIRD | Config::TYPE_DOG);
//dog bird
new Config(Config::TYPE_ALL & ~Config::TYPE_DOG & ~Config::TYPE_CAT);
//rat lion bird

¿Que es esto?

Esta es una colección de preguntas que surgen de vez en cuando sobre la sintaxis en PHP. Este es también un wiki de la comunidad, por lo que todos están invitados a participar en el mantenimiento de esta lista.

¿Por qué es esto?

Solía ​​ser difícil encontrar preguntas sobre operadores y otros tokens de sintaxis.
La idea principal es tener enlaces a preguntas existentes sobre el desbordamiento de pila, por lo que es más fácil para nosotros hacer referencia a ellas, no copiar el contenido del Manual de PHP.

¹ Nota: Desde enero de 2013, el Desbordamiento de pila admite caracteres especiales . Simplemente rodee los términos de búsqueda entre comillas, por ejemplo, [php] "==" vs "==="

¿Qué debo hacer aquí?

Si alguien lo ha señalado aquí porque ha formulado una pregunta de este tipo, encuentre la sintaxis específica a continuación. Las páginas vinculadas al manual de PHP junto con las preguntas vinculadas probablemente responderán a su pregunta en ese momento. Si es así, te animamos a votar por la respuesta. Esta lista no pretende sustituir la ayuda proporcionada por otros.

La lista

Si su token en particular no aparece en la lista a continuación, puede encontrarlo en la Lista de tokens de analizador .

& Bitwise Operadores o References

=& References

&= Operadores de Bitwise

&& Operadores lógicos

% operadores aritméticos

!! Operadores logicos

@ Operadores de control de errores

?: Operador Ternario

?? Operador Nulo Coalesce (desde PHP 7)

: Sintaxis alternativa para estructuras de control , operador ternario

:: Operador de resolución de alcance

\ Namespaces

-> Clases y objetos

=> Arrays

^ Operadores bitwise

>> Operadores de Bitwise

<< Operadores de Bitwise

<<< Heredoc o Nowdoc

= Operadores de Asignación

== Operadores de comparación

=== Operadores de comparación

!== Operadores de comparación

!= Operadores de comparación

<> Operadores de comparación

<=> Operadores de comparación (desde PHP 7.0)

  • Operador de la nave espacial (comparación de tres vías)

| Operadores de Bitwise

|| Operadores logicos

~ Operadores bitwise

+ Operadores aritméticos , Operadores de matrices

+= y -= Operadores de asignación

++ y -- Incremento / decremento de operadores

.= Operadores de Asignación

. Operadores de cuerdas

, Argumentos de la función

Declaraciones Variables

$$ Variables variables

` Operador de Ejecución

<?= Etiquetas cortas abiertas

[] Arrays (sintaxis corta desde PHP 5.4)

<? Apertura y cierre de etiquetas.

... Argumento desempaquetado (desde PHP 5.6)

** Exponentiation (desde PHP 5.6)

# Comentario de estilo shell de una línea


PREGUNTA:

¿Qué significa => ?

RESPONDER:

=> Es el símbolo que los humanos decidimos usar para separar pares "Key" => "Value" en matrices asociativas.

ELABORANDO:

Para entender esto, tenemos que saber qué son matrices asociativas. Lo primero que surge cuando un programador convencional piensa en una matriz ( en PHP ) sería algo similar a:

$myArray1 = array(2016, "hello", 33);//option 1

$myArray2 = [2016, "hello", 33];//option 2

$myArray3 = [];//option 3
$myArray3[] = 2016; 
$myArray3[] = "hello"; 
$myArray3[] = 33;

Donde, si quisiéramos llamar a la matriz en una parte posterior del código, podríamos hacerlo:

echo $myArray1[1];// output: hello
echo $myArray2[1];// output: hello
echo $myArray3[1];// output: hello

Hasta ahora tan bueno. Sin embargo, como seres humanos, nos puede resultar difícil recordar que el índice [0] de la matriz es el valor del año 2016, el índice [1] de la matriz es un saludo , y el índice [2] de la matriz es un simple valor entero La alternativa que tendríamos entonces es usar lo que se llama una matriz asociativa . Una matriz asociativa tiene algunas diferencias con respecto a una matriz secuencial ( que es lo que eran los casos anteriores, ya que incrementan el índice utilizado en una secuencia predeterminada, incrementando en 1 por cada valor siguiente ).

Diferencias ( entre una matriz secuencial y asociativa ):

  • Al anular la declaración de una matriz asociativa, no solo incluye el value de lo que desea colocar en la matriz, sino que también coloca el valor de índice (llamado key ) que desea utilizar al llamar a la matriz en partes posteriores del código. La siguiente sintaxis se usa durante su declaración: "key" => "value" .

  • Cuando se usa la matriz asociativa, el valor key se colocará dentro del índice de la matriz para recuperar el value deseado.

Por ejemplo:

    $myArray1 = array( 
        "Year" => 2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33);//option 1

    $myArray2 = [ 
        "Year" =>  2016, 
        "Greetings" => "hello", 
        "Integer_value" => 33];//option 2

    $myArray3 = [];//option 3
    $myArray3["Year"] = 2016; 
    $myArray3["Greetings"] = "hello"; 
    $myArray3["Integer_value"] = 33;

Y ahora, para recibir la misma salida que antes, el valor de key se usaría en el índice de arrays:

echo $myArray1["Greetings"];// output: hello
echo $myArray2["Greetings"];// output: hello
echo $myArray3["Greetings"];// output: hello

PUNTO FINAL:

Entonces, a partir del ejemplo anterior, es bastante fácil ver que el símbolo => se usa para expresar la relación de una matriz asociativa entre cada uno de los pares key y value en una matriz DURANTE el inicio de los valores dentro de la matriz.


Operador bitwise

Que es un poco Un bit es una representación de 1 o 0. Básicamente OFF (0) y ON (1)

¿Qué es un byte? Un byte se compone de 8 bits y el valor más alto de un byte es 255, lo que significaría que cada bit se establece. Veremos por qué el valor máximo de un byte es 255.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------

Esta representación de 1 byte.

1 + 2 + 4 + 8 + 16 + 32 + 64 + 128 = 255 (1 byte)

Algunos ejemplos para una mejor comprensión.

El operador "AND": &

$a =  9;
$b = 10;
echo $a & $b;

Esto daría como resultado el número 8. ¿Por qué? Bueno, veamos usando nuestro ejemplo de mesa.

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      &     |   0|  0|  0|  0| 1| 0| 0| 0|
------------------------------------------- 

Así que puedes ver en la tabla que el único bit que comparten juntos es el 8 bit.

Segundo ejemplo

$a =  36;
$b = 103;
echo $a & $b; // This would output the number 36.
$a = 00100100
$b = 01100111

Los dos bits compartidos son 32 y 4, que cuando se suman devuelven 36.

El operador "O": |

$a =  9;
$b = 10;
echo $a | $b;

Esto daría como resultado el número 11. ¿Por qué?

-------------------------------------------
|      1 Byte ( 8 bits )                  |
-------------------------------------------
|Place Value | 128| 64| 32| 16| 8| 4| 2| 1|     
-------------------------------------------
|      $a    |   0|  0|  0|  0| 1| 0| 0| 1|    
-------------------------------------------
|      $b    |   0|  0|  0|  0| 1| 0| 1| 0|
------------------------------------------- 
|      |     |   0|  0|  0|  0| 1| 0| 1| 1|
-------------------------------------------

Notará que tenemos 3 bits establecidos, en las columnas 8, 2 y 1. Súmalos: 8 + 2 + 1 = 11.


Constantes mágicas : aunque no son solo símbolos sino una parte importante de esta familia de fichas. Hay ocho constantes mágicas que cambian dependiendo de dónde se usan.

__LINE__ : el número de línea actual del archivo.

__FILE__ : La ruta completa y el nombre del archivo. Si se utiliza dentro de una inclusión, se devuelve el nombre del archivo incluido. Desde PHP __FILE__ , __FILE__ siempre contiene una ruta absoluta con enlaces simbólicos resueltos, mientras que en versiones anteriores contenía rutas relativas en algunas circunstancias.

__DIR__ : El directorio del archivo. Si se utiliza dentro de una inclusión, se devuelve el directorio del archivo incluido. Esto es equivalente a dirname(__FILE__) . Este nombre de directorio no tiene una barra inclinada a menos que sea el directorio raíz. (Añadido en PHP 5.3.0.)

__FUNCTION__ : El nombre de la función. (Agregado en PHP 4.3.0) A partir de PHP 5, esta constante devuelve el nombre de la función como se declaró (distingue entre mayúsculas y minúsculas). En PHP 4 su valor siempre está en minúscula.

__CLASS__ : El nombre de la clase. (Agregado en PHP 4.3.0) A partir de PHP 5, esta constante devuelve el nombre de la clase tal como fue declarado (distingue entre mayúsculas y minúsculas). En PHP 4 su valor siempre está en minúscula. El nombre de la clase incluye el espacio de nombres en el que se declaró (por ejemplo, Foo\Bar ). Tenga en cuenta que a partir de PHP 5.4 __CLASS__ funciona también en rasgos. Cuando se usa en un método de rasgo, __CLASS__ es el nombre de la clase en que se usa el rasgo.

__TRAIT__ : El nombre del rasgo. (Agregado en PHP 5.4.0) A partir de PHP 5.4, esta constante devuelve el rasgo tal como fue declarado (distingue entre mayúsculas y minúsculas). El nombre del rasgo incluye el espacio de nombres en el que se declaró (por ejemplo, Foo\Bar ).

__METHOD__ : El nombre del método de clase. (Agregado en PHP 5.0.0) El nombre del método se devuelve como se declaró (distingue entre mayúsculas y minúsculas).

__NAMESPACE__ : el nombre del espacio de nombres actual ( __NAMESPACE__ mayúsculas y minúsculas). Esta constante se define en tiempo de compilación (Agregada en PHP 5.3.0).

Source


Nulo coalesce operador php

El operador de unión nula (??) se ha agregado a PHP7 para el caso común de la necesidad de usar un ternario junto con isset (). Devuelve su primer operando si existe y no es NULL; de lo contrario, devuelve su segundo operando, como el siguiente ejemplo:

$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody'; 

Operador coalescente nulo (??)

Este operador se ha agregado en PHP 7.0 para el caso común de la necesidad de utilizar un operador ternario junto con isset() . Devuelve su primer operando si existe y no es NULL ; De lo contrario, devuelve su segundo operando.

<?php
// Fetches the value of $_GET['user'] and returns 'nobody'
// if it does not exist.
$username = $_GET['user'] ?? 'nobody';
// This is equivalent to:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// Coalescing can be chained: this will return the first
// defined value out of $_GET['user'], $_POST['user'], and
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>

Operador de nave espacial <=> (Añadido en PHP 7)

Ejemplos para <=> operador de nave espacial (PHP 7, Fuente: Manual de PHP):

Números enteros, flotadores, cadenas, matrices y objetos para la comparación de variables de tres vías.

// Integers
echo 10 <=> 10; // 0
echo 10 <=> 20; // -1
echo 20 <=> 10; // 1

// Floats
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1

echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1

// Arrays
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1

// Objects
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0

$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "c"]; 
echo $a <=> $b; // -1

$a = (object) ["a" => "c"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 1

// only values are compared
$a = (object) ["a" => "b"]; 
$b = (object) ["b" => "b"]; 
echo $a <=> $b; // 1

{} Llaves

Y algunas palabras sobre el último post.

$x[4] = 'd'; // it works
$x{4} = 'd'; // it works

$echo $x[4]; // it works
$echo $x{4}; // it works

$x[] = 'e'; // it works
$x{} = 'e'; // does not work

$x = [1, 2]; // it works
$x = {1, 2}; // does not work

echo "${x[4]}"; // it works
echo "${x{4}}"; // does not work

echo "{$x[4]}"; // it works
echo "{$x{4}}"; // it works

Operadores de incremento / decremento

++ operador de incremento

-- operador decremento

Example    Name              Effect
---------------------------------------------------------------------
++$a       Pre-increment     Increments $a by one, then returns $a.
$a++       Post-increment    Returns $a, then increments $a by one.
--$a       Pre-decrement     Decrements $a by one, then returns $a.
$a--       Post-decrement    Returns $a, then decrements $a by one.

Estos pueden ir antes o después de la variable.

Si se coloca antes de la variable, primero se realiza la operación de incremento / decremento a la variable y luego se devuelve el resultado. Si se coloca después de la variable, primero se devuelve la variable, luego se realiza la operación de incremento / decremento.

Por ejemplo:

$apples = 10;
for ($i = 0; $i < 10; ++$i) {
    echo 'I have ' . $apples-- . " apples. I just ate one.\n";
}

Ejemplo vivo

En el caso anterior se usa ++$i , ya que es más rápido. $i++ tendría los mismos resultados.

El pre-incremento es un poco más rápido, porque realmente incrementa la variable y después de eso "devuelve" el resultado. El incremento posterior crea una variable especial, copia allí el valor de la primera variable y solo después de que se utiliza la primera variable, reemplaza su valor por el de la segunda.

Sin embargo, debe usar $apples-- , ya que primero desea mostrar el número actual de manzanas, y luego desea restar una de ellas.

También puedes incrementar letras en PHP:

$i = "a";
while ($i < "c") {
    echo $i++;
}

Una vez que se llega a z aa es la siguiente, y así sucesivamente.

Tenga en cuenta que las variables de caracteres pueden incrementarse pero no disminuirse, y aún así solo se admiten caracteres ASCII simples (az y AZ).

Postes de desbordamiento de pila:


Una visión general de los operadores en PHP :

Operadores logicos:

  • $ a & Y $ b: VERDADERO si tanto $ a como $ b son VERDADEROS.
  • $ a || $ b: VERDADERO si $ a o $ b es VERDADERO.
  • $ a xor $ b: VERDADERO si $ ao $ b es VERDADERO, pero no ambos.
  • ! $ a: VERDADERO si $ a no es VERDADERO.
  • $ a y $ b: VERDADERO si tanto $ a como $ b son VERDADEROS.
  • $ ao $ b: VERDADERO si $ ao $ b es VERDADERO.

Operadores de comparación:

  • $ a == $ b: VERDADERO si $ a es igual a $ b después del tipo de malabarismo.
  • $ a === $ b: VERDADERO si $ a es igual a $ b, y son del mismo tipo.
  • $ a! = $ b: VERDADERO si $ a no es igual a $ b después del tipo de malabarismo.
  • $ a <> $ b: VERDADERO si $ a no es igual a $ b después del tipo de malabarismo.
  • $ a! == $ b: VERDADERO si $ a no es igual a $ b, o no son del mismo tipo.
  • $ a <$ b : VERDADERO si $ a es estrictamente menor que $ b.
  • $ a> $ b : VERDADERO si $ a es estrictamente mayor que $ b.
  • $ a <= $ b : VERDADERO si $ a es menor o igual que $ b.
  • $ a> = $ b : VERDADERO si $ a es mayor o igual que $ b.
  • $ a <=> $ b : un número entero menor que, igual o mayor que cero cuando $ a es respectivamente menor que, igual o mayor que $ b. Disponible a partir de PHP 7.
  • $ a? $ b: $ c : si $ a return $ b, si no, devuelve $ c ( operador ternario )
  • $ a ?? $ c : igual que $ a? $ a: $ c ( operador de unión nula - requiere PHP> = 7)

Operadores aritméticos:

  • - $ a : Opuesto a $ a.
  • $ a + $ b : Suma de $ a y $ b.
  • $ a - $ b : Diferencia de $ a y $ b.
  • $ a * $ b : Producto de $ a y $ b.
  • $ a / $ b : Cociente de $ a y $ b.
  • $ a% $ b : Resto de $ a dividido por $ b.
  • $ a ** $ b : Resultado de aumentar $ a al poder $ b'th (introducido en PHP 5.6)

Operadores de aumento / decremento:

  • ++ $ a : Incrementa $ a por uno, luego devuelve $ a.
  • $ a ++ : devuelve $ a, luego incrementa $ a por uno.
  • - $ a : Disminuye $ a por uno, luego devuelve $ a.
  • $ a-- : devuelve $ a, luego disminuye $ a por uno.

Operadores de bitwise:

  • $ a y $ b : se configuran los bits que se establecen tanto en $ a como en $ b.
  • $ a | $ b : se configuran los bits que se establecen en $ a o $ b.
  • $ a ^ $ b : Bits que se configuran en $ a o $ b, pero no se establecen ambos.
  • ~ $ a : los bits que se configuran en $ a no se configuran, y viceversa.
  • $ a << $ b : desplace los bits de $ a $ b pasos hacia la izquierda (cada paso significa "multiplica por dos")
  • $ a >> $ b : Mueva los bits de los pasos de $ a $ b hacia la derecha (cada paso significa "dividir por dos")

Operadores de cuerdas:

  • $ a. $ b : concatenación de $ ay $ b.

Operadores de matrices:

  • $ a + $ b : Unión de $ a y $ b.
  • $ a == $ b : VERDADERO si $ a y $ b tienen los mismos pares clave / valor.
  • $ a === $ b : VERDADERO si $ a y $ b tienen los mismos pares clave / valor en el mismo orden y de los mismos tipos.
  • $ a! = $ b : VERDADERO si $ a no es igual a $ b.
  • $ a <> $ b : VERDADERO si $ a no es igual a $ b.
  • $ a! == $ b : VERDADERO si $ a no es idéntico a $ b.

Operadores de Asignación:

  • $ a = $ b : el valor de $ b se asigna a $ a
  • $ a + = $ b : Igual que $ a = $ a + $ b
  • $ a - = $ b : Igual que $ a = $ a - $ b
  • $ a * = $ b : Igual que $ a = $ a * $ b
  • $ a / = $ b : Igual que $ a = $ a / $ b
  • $ a% = $ b : Igual que $ a = $ a% $ b
  • $ a ** = $ b : Igual que $ a = $ a ** $ b
  • $ a. = $ b : Igual que $ a = $ a. $ b
  • $ a y = $ b : Igual que $ a = $ a y $ b
  • $ a | = $ b : Igual que $ a = $ a | $ b
  • $ a ^ = $ b : Igual que $ a = $ a ^ $ b
  • $ a << = $ b : Igual que $ a = $ a << $ b
  • $ a >> = $ b : Igual que $ a = $ a >> $ b

Nota

and operador y / or operador tienen menor prioridad que el operador de asignación = .

Esto significa que $a = true and false; es equivalente a ($a = true) and false .

En la mayoría de los casos, probablemente querrá usar && y || , que se comportan de una manera conocida desde lenguajes como C, Java o JavaScript.


Operador nulo coalesce "??" (Añadido en PHP 7)

No es el nombre más atractivo para un operador, pero PHP 7 trae la fusión nula bastante útil, así que pensé en compartir un ejemplo.

En PHP 5, ya tenemos un operador ternario, que prueba un valor y luego devuelve el segundo elemento si devuelve verdadero y el tercero si no lo hace:

echo $count ? $count : 10; // outputs 10

También hay una taquigrafía para eso que te permite omitir el segundo elemento si es el mismo que el primero: echo $ count?: 10; // también salidas 10

En PHP 7 obtenemos además el ?? operador que, en lugar de indicar una confusión extrema, así es como usualmente usaría dos signos de interrogación, en lugar de eso, nos permite encadenar una cadena de valores. Leyendo de izquierda a derecha, el primer valor que existe y no es nulo es el valor que se devolverá.

// $a is not set
$b = 16;

echo $a ?? 2; // outputs 2
echo $a ?? $b ?? 7; // outputs 16

Este constructo es útil para dar prioridad a uno o más valores que provienen de la entrada del usuario o de la configuración existente, y se pueden recuperar de forma segura en un valor predeterminado dado si falta esa configuración. Es una especie de característica pequeña, pero es una que sé que usaré tan pronto como mis aplicaciones se actualicen a PHP 7.


Syntax    Name             Description

x == y    Equality         True if x and y have the same key/value pairs
x != y    Inequality       True if x is not equal to y
x === y   Identity         True if x and y have the same key/value pairs
                            in the same order and of the same types
x !== y   Non-identity     True if x is not identical to y
++ x      Pre-increment    Increments x by one, then returns x
x ++      Post-increment   Returns x, then increments x by one
-- x      Pre-decrement    Decrements x by one, then returns x
x --      Post-decrement   Returns x, then decrements x by one
x and y   And              True if both x and y are true x=6 y=3
                           (x < 10 and y > 1) returns true 
x && y    And              True if both x and y are true x=6 y=3
                           (x < 10 && y > 1) returns true
a . b     Concatenation    Concatenate two strings: "Hi" . "Ha"

<=> Operador de la nave espacial

Añadido en PHP 7

El operador de la nave espacial <=> es el último operador de comparación agregado en PHP 7. Es un operador binario no asociativo con la misma prioridad que los operadores de igualdad ( == != , === !== ). Este operador permite una comparación de tres vías más simple entre los operandos de la izquierda y la derecha.

El operador da como resultado una expresión entera de:

  • 0 cuando ambos operandos son iguales
  • Menos de 0 cuando el operando de la izquierda es menor que el operando de la derecha
  • Mayor que 0 cuando el operando de la izquierda es mayor que el operando de la derecha

p.ej

1 <=> 1; // 0
1 <=> 2; // -1
2 <=> 1; // 1

Una buena aplicación práctica de usar este operador sería, en comparación, las devoluciones de llamada de tipo que se espera que devuelvan un entero cero, negativo o positivo basado en una comparación de tres vías entre dos valores. La función de comparación pasada a usort es uno de estos ejemplos.

Antes de PHP 7 escribirías ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    if ($a < $b) {
        return -1;
    } elseif ($a > $b) {
        return 1;
    } else {
        return 0;
    }
});

Desde PHP 7 puedes escribir ...

$arr = [4,2,1,3];

usort($arr, function ($a, $b) {
    return $a <=> $b;
});

Operadores de Tipo

instanceof se utiliza para determinar si una variable de PHP es un objeto instanciado de una determinada clase.

<?php
class mclass { }
class sclass { }
$a = new mclass;
var_dump($a instanceof mclass);
var_dump($a instanceof sclass);

El ejemplo anterior dará como resultado:

bool(true)
bool(false)

Motivo: el ejemplo anterior $a es un objeto de mclass por mclass tanto, use solo un mclass data sin instancia con sclass

Ejemplo con herencia

<?php 
class pclass { } 
class childclass extends pclass { } 
$a = new childclass; 
var_dump($a instanceof childclass); 
var_dump($a instanceof pclass);

El ejemplo anterior dará como resultado:

bool(true)
bool(true)

Ejemplo con clon

<?php 
class cloneable { } 
$a = new cloneable;
$b = clone $a; 
var_dump($a instanceof cloneable); 
var_dump($b instanceof cloneable);

El ejemplo anterior dará como resultado:

bool(true)
bool(true)

Supongamos que no hemos utilizado el operador "@", nuestro código se vería así:

$fileHandle = fopen($fileName, $writeAttributes);

¿Y si no se encuentra el archivo que estamos intentando abrir? Se mostrará un mensaje de error.

Para suprimir el mensaje de error, estamos utilizando el operador "@" como:

$fileHandle = @fopen($fileName, $writeAttributes);




php operators symbols php-5.3