Operadores incrementales / decrecientes

++ operador de incremento

-- operador de 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, la operación de incremento / decremento se realiza en la variable en el primer luego se devuelve el resultado. Si se coloca después de la variable, la variable es en el primer devuelto, entonces 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 ++$i se utiliza, ya que es más rápido. $i++ tendría los mismos resultados.

El preincremento es un poco más rápido porque realmente incrementa la variable y luego '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 usa la primera variable, reemplaza su valor por el de la segunda.

Sin embargo, debe utilizar $apples--, ya que primero, desea mostrar el número actual de manzanas, y luego quieres restarle uno.

También puede incrementar letras en PHP:

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

Once z es alcanzado aa es el siguiente, y así sucesivamente.

Tenga en cuenta que las variables de caracteres se pueden incrementar pero no disminuir y, aun así, solo se admiten caracteres ASCII simples (az y AZ).

Publicaciones de desbordamiento de pila:

• Entendiendo el Incremento

Operador bit a bit

¿Qué 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 todos los bits están establecidos. 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 "Y": &

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

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

-------------------------------------------
|      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|
------------------------------------------- 

Entonces, puede ver en la tabla que el único bit que comparten juntos es el de 8 bits.

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. Sume esos: 8 + 2 + 1 = 11.

<=> Operador de nave espacial

Agregado en PHP 7

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

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

• 0 cuando ambos operandos son iguales
• Menos que 0 cuando el operando de la izquierda es menor que el operando de la derecha
• Más 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 del uso de este operador sería en las devoluciones de llamada de tipo de comparación que se espera que devuelvan un número entero cero, negativo o positivo basado en una comparación de tres vías entre dos valores. La función de comparación pasó a usort Es uno de esos 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;
    // return -1 * ($a <=> $b); // for reversing order
});

_ Alias ​​para gettext ()

El carácter de subrayado '_' como en _() es un alias para el gettext() función.

Constantes mágicas: Aunque estos no son solo símbolos, sino una parte importante de esta familia de tokens. Hay ocho constantes mágicas que cambian dependiendo de dónde se utilicen.

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

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

__DIR__: El directorio del archivo. Si se usa 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 al final a menos que sea el directorio raíz. (Agregado 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 tal como se declaró (distingue entre mayúsculas y minúsculas). En PHP 4, su valor siempre está en minúsculas.

__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 se declaró (distingue entre mayúsculas y minúsculas). En PHP 4, su valor siempre está en minúsculas. El nombre de la clase incluye el espacio de nombres en el que se declaró (p. Ej. 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 la 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 se declaró (distingue entre mayúsculas y minúsculas). El nombre del rasgo incluye el espacio de nombres en el que se declaró (p. Ej. Foo\Bar).

__METHOD__: El nombre del método de la 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 (distingue entre mayúsculas y minúsculas). Esta constante se define en tiempo de compilación (agregada en PHP 5.3.0).

Fuente

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)

Razón: Ejemplo anterior $a es un objeto de la mclass así que usa solo un mclass datos no instancia de con el 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 Clone

<?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)

Una visión general de operadores en PHP:

Operadores logicos:

• $ a && $ b: VERDADERO si tanto $ a como $ b son VERDADEROS.
• $ a || $ b: VERDADERO si $ a o $ b es VERDADERO.
• $ a xo $ b: VERDADERO si $ a o $ b es VERDADERO, pero no ambos.
• ! $ a: VERDADERO si $ a no es VERDADERO.
• $ ay $ b: VERDADERO si tanto $ a como $ b son VERDADEROS.
• $ a o $ b: VERDADERO si $ a o $ 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 si 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, igual o mayor que cero cuando $ a es respectivamente menor, igual o mayor que $ b. Disponible a partir de PHP 7.
• $ a? $ b: $ c : si $ a devuelve $ b si no devuelve $ c (operador ternario)
• $ a ?? $ c : ¿Igual que $ a? $ a: $ c (operador de fusión nula - requiere PHP> = 7)

Operadores aritméticos:

• - $ a : Opuesto a $ a.
• $ a + $ b : Suma de $ ay $ b.
• $ a - $ b : Diferencia de $ ay $ b.
• $ a * $ b : Producto de $ ay $ b.
• $ a / $ b : Cociente de $ ay $ b.
• $ a% $ b : Resto de $ a dividido por $ b.
• $ a ** $ b : Resultado de elevar $ a a la potencia $ b'th (introducido en PHP 5.6)

Operadores incrementales / decrecientes:

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

Operadores bit a bit:

• $ a y $ b : Se establecen los bits que se establecen tanto en $ a como en $ b.
• $ a | $ b : Se establecen los bits que se establecen en $ a o $ b.
• $ a ^ $ b : Se establecen los bits que se establecen en $ a o $ b pero no en ambos.
• ~ $ a : Los bits que se establecen en $ a no se establecen y viceversa.
• $ a << $ b : Desplaza los bits de $ a $ b pasos hacia la izquierda (cada paso significa "multiplicar por dos")
• $ a >> $ b : Mueve los bits de $ a $ b pasos hacia la derecha (cada paso significa "dividir por dos")

Operadores de cadenas:

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

Operadores de matrices:

• $ a + $ b : Unión de $ ay $ b.
• $ a == $ b : VERDADERO si $ ay $ b tienen los mismos pares clave / valor.
• $ a === $ b : VERDADERO si $ ay $ 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 & = $ 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 : El valor de $ b se asigna a $ a si $ a es nulo o no está definido (operador de asignación de fusión nula - requiere PHP> = 7.4)

Nota:

and operador y or El operador tiene menor precedencia 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 desee utilizar && y ||, que se comportan de una forma conocida en lenguajes como C, Java o JavaScript.

Operador de nave espacial <=> (Agregado en PHP 7)

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

Enteros, flotantes, 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
// Comparison is case-sensitive
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

• Bloques: ¿llaves / sin llaves?
• Llaves en cadena en PHP
• Llaves PHP en notación de matriz

Y algunas palabras sobre la última publicación

$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

Operador de fusión nulo (??)

Este operador se ha agregado en PHP 7.0 para el caso común de necesitar usar 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';
?>

Cadenas PHP: Las cadenas de PHP se pueden especificar de cuatro formas, no solo de dos formas:

1) Cadenas de comillas individuales:

$string = 'This is my string'; // print This is my string

2) Cadenas de comillas dobles:

$str = 'string';

$string = "This is my $str"; // print This is my string

3) Heredoc:

$string = <<<EOD
This is my string
EOD; // print This is my string

4) Nowdoc (desde PHP 5.3.0):

$string = <<<'END_OF_STRING'
    This is my string 
END_OF_STRING; // print This is my string

PREGUNTA:

¿Qué => significa?

RESPONDER:

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

ELABORANDO:

Para entender esto, tenemos que saber qué son las 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 alguna parte posterior del código, podríamos hacer:

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

Hasta aquí todo bien. Sin embargo, como seres humanos, es posible que nos resulte difícil recordar ese índice [0] de la matriz es el valor de la año 2016, índice [1] de la matriz es un saludosy el índice [2] de la matriz es un simple valor entero. La alternativa que tendríamos entonces es usar lo que se llama un Matriz asociativa. Una matriz asociativa tiene algunas diferencias con una Matriz secuencial (que es lo que eran los casos anteriores ya que incrementan el índice usado en una secuencia predeterminada, incrementando en 1 para cada valor siguiente).

Diferencias (entre una matriz secuencial y asociativa):

• Durante la declaración de una matriz asociativa, no solo incluye el value de lo que quieres poner en la matriz, pero también pones el valor del índice (llamado key) que desea usar al llamar a la matriz en partes posteriores del código. La siguiente sintaxis se utiliza durante su declaración: "key" => "value".

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

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 key El valor se usaría en el índice de matrices:

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

PUNTO FINAL:

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

Pregunta:

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

Operador PHP "&"

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

& Por lo general, comprueba que los bits que están configurados tanto en $ a como en $ b estén establecidos.

¿Ha notado siquiera 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);

Entonces, detrás de todo lo anterior está el juego de operadores bit a bit y bits.

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

La mayoría de la gente ya ha leído los documentos, pero no se basó en el caso de uso del mundo real de estos operadores bit a bit.

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

== se utiliza para comprobar la igualdad sin considerando variable tipo de datos

=== se utiliza para comprobar la igualdad de ambas La variable propuesta de y tipo de datos

Ejemplo

$a = 5

1. if ($a == 5) - evaluará como verdadero

2. if ($a == '5') - se evaluará como verdadero, porque al comparar ambos valores, PHP convierte internamente ese valor de cadena en un número entero y luego compara ambos valores

3. if ($a === 5) - evaluará como verdadero

4. if ($a === '5') - se evaluará como falso, porque el valor es 5, pero este valor 5 no es un número entero.

Operador Null Coalesce "??" (Agregado 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 abreviatura para eso que le permite omitir el segundo elemento si es el mismo que el primero: echo $ count?: 10; // también produce 10

En PHP 7 obtenemos adicionalmente el ?? operador que, en lugar de indicar una confusión extrema, que es la forma en que normalmente usaría dos signos de interrogación juntos, 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

Esta construcción es útil para dar prioridad a uno o más valores que provienen quizás de la entrada del usuario o de la configuración existente, y recurrir con seguridad a un valor predeterminado dado si falta esa configuración. Es una característica pequeña, pero sé que usaré tan pronto como mis aplicaciones se actualicen a PHP 7.

Declaración de tipo de retorno que acepta valores NULL

PHP 7 agrega soporte para declaraciones de tipo de retorno. De manera similar a las declaraciones de tipo de argumento, las declaraciones de tipo de retorno especifican el tipo de valor que se devolverá desde una función. Los mismos tipos están disponibles para declaraciones de tipo de retorno que están disponibles para declaraciones de tipo de argumento.

La escritura estricta también tiene un efecto en las declaraciones de tipo de retorno. En el modo débil predeterminado, los valores devueltos se forzarán al tipo correcto si aún no son de ese tipo. En modo fuerte, el valor devuelto debe ser del tipo correcto; de lo contrario, se lanzará un TypeError.

A partir de PHP 7.1.0, los valores de retorno se pueden marcar como anulables al anteponer el nombre del tipo con un signo de interrogación (?). Esto significa que la función devuelve el tipo especificado o NULL.

<?php
function get_item(): ?string {
    if (isset($_GET['item'])) {
        return $_GET['item'];
    } else {
        return null;
    }
}
?>

Fuente

Three DOTS como operador de Splat (...) (desde PHP 5.6)

PHP tiene un operador "..." (Tres puntos) que se conoce como Operador Splat. Se utiliza para pasar un número arbitrario de parámetros en una función y este tipo de función se llama Funciones Variadic. Tomemos ejemplos del uso de "..." (tres puntos).

Ejemplo 1:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

echo calculateNumbers(10, 20, 30, 40, 50);

//Output 150
?>

Cada argumento de la función calculateNumbers () pasa a través de $ params como una matriz cuando se usa "…".

Hay muchas formas diferentes de utilizar el operador "...". A continuación algunos ejemplos:

Ejemplo 2:

<?php
function calculateNumbers($no1, $no2, $no3, $no4, $no5){
    $total = $no1 + $no2 + $no3 + $no4 + $no5;
    return $total;
}

$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers(...$numbers);

//Output 150
?>

Ejemplo 3:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}
$no1 = 70;
$numbers = array(10, 20, 30, 40, 50);
echo calculateNumbers($no1, ...$numbers);

//Output 220
?>

Ejemplo 4:

<?php
function calculateNumbers(...$params){
    $total = 0;
    foreach($params as $v){
        $total = $total + $v;
    }
    return $total;
}

$numbers1 = array(10, 20, 30, 40, 50);
$numbers2 = array(100, 200, 300, 400, 500);
echo calculateNumbers(...$numbers1, ...$numbers2);

//Output 1650

?>

Operador NullSafe "? ->" (posiblemente) desde php8

En PHP8 se ha aceptado este nuevo operador, puedes encontrar la documentación aquí. ?-> es el NullSafe Operator, vuelve null en caso de que intente invocar funciones u obtener valores de null...

Ejemplos:

<?php
$obj = null;
$obj = $obj?->attr; //return null
$obj = ?->funct(); // return null
$obj = $objDrive->attr; // Error: Trying to get property 'attr' of non-object
?>

? -> Operador NullSafe

Agregado en PHP 8.0

Es el NullSafe Operator, vuelve null en caso de que intente invocar funciones u obtener valores de null. El operador Nullsafe se puede encadenar y se puede utilizar tanto en los métodos como en las propiedades.

$objDrive = null;
$drive = $objDrive?->func?->getDriver()?->value; //return null
$drive = $objDrive->func->getDriver()->value; // Error: Trying to get property 'func' of non-object

El operador Nullsafe no funciona con claves de matriz:

$drive['admin']?->getDriver()?->value //Warning: Trying to access array offset on value of type null

$drive = [];
$drive['admin']?->getAddress()?->value //Warning: Undefined array key "admin"