Scalars Type hints:

PHP 7 agrega los type hints int, float, string y bool a los que ya existian que era Objetos y array.

function sendEmail(string $email, int $times, float $number, bool $sendNow = TRUE) {
    //..
}

Esta declaración no fuerza la comprobación, solo intenta convertir el valor al tipo declarado. Si agregamos la directiva declare(strict_types=1); al principio del archivo, si forzaremos la comprobación, pero solo en ese archivo.

Return type hints

Tambien podemos utilizar los mismos para el retorno de funciones o métodos

function sayHello(string $name) : string {
    return 'Hello '.$name;
}

Si retornamos otro valor, recibiremos un error \TypeError.

Anonymous classes:

Las clases anónimas son iguales a las clases «nombradas». Salvo que no se pueden serializar

$obj = new class($a, $b) {
    private $a;
    private $b;
    
    public function __construct($a, $b) {
        $this->a = $a;
        $this->b = $b;
    }
};

Generator:

Un generador nos permite iterar sobre datos sin crear un array. Los generadores son como una función que van produciendo valores, en vez de retornar solo uno.

function par() {
    for ($i = 1; $i <= 10; $i++) {
        if ($i % 2 == 0) {
            yield $i;
        }
    }
}



foreach(par() as $par) {
    echo $par;
}
// 2 4 6 8 10

function numeros() { 
    yield 1; 
    yield 3; 
}
foreach(numeros() as $num) {
   echo $num;
}
//1 3

Return en un Generator

function numeros() { 
    yield 1; 
    yield 3;
    return 5; 
}

foreach(numeros() as $num) {
    echo $num;
}
//1 3

echo numeros()->getReturn();
// 5

Cuando iteramos solo se produciran los valores con yield. Luego podemos invocar a return. Si invocamos a return antes de iterar, obtenemos una excepción.

The null coalesce operator:

Este nuevo operador (??) nos permite escribir expresiones más cortas.

$name = $_GET['name'] ?? 'N/A';

Retorna el valor del primer operando si existe y es distinto de null sino, devuelve el segundo operando.

The spaceship operator:

Nos permite hacer comparaciones de «3 vías», es decir que el resultado de la comparación puede ser true, false y otro valor más. (expr) <=> (expr)
Este operador retorna:
A. 0 si los operandos son iguales
B. 1 si el operando de la izquierda es mayor
C. -1 si el operando de la derecha es mayor

Constant arrays

// Constante de clase
class MyApp {
    const APP = [
        'name' => 'MyApp',
        'edition' => 'Beta',
        'version' => '2.1.2',
        'licence' => 'MIT'
        ];
}

interface MyApp {
    const APP = [
        'name' => 'MyApp',
        'edition' => 'Beta',
        'version' => '2.1.2',
        'licence' => 'MIT'
        ];
}
// Constante utilizando define
define('APP', [
        'name' => 'MyApp',
        'edition' => 'Beta',
        'version' => '2.1.2',
        'licence' => 'MIT'
        ];
}

Throwables:

Podemos tratar como excepciones a errores en un try catch

try {
    $mailer = new Mailer($transport); -> esta linea devuelve un \Error no un \Exception
} catch (\Throwable $e) {
     echo 'Error!';
} finally {
     echo 'continuar!';
}

Nullable types

function nombre(?string $nombre) {
    echo $name;
}
nombre(); // invalido
nombre(null); // valido

function nombre2(?string $nombre = null) {
    echo $name;
}
nombre2(); // valido
nombre2(null); // valido
nombre2('John'); // valido

Void return types

function A(): void {
    // valido
}
function B(): void {
     return; // valido
}
function C(): void {
    return null; // invalido
}
function D(): void {
    return 1; // invalido
}