PHP 8 è qui! L'aggiornamento principale è stato rilasciato il 26 novembre 2020 e ci porta alcuni cambiamenti fondamentali così come molte nuove caratteristiche. Il nostro sviluppatore Marten spiega in quale caso PHP 8 porta davvero a migliori prestazioni e se dovresti già aggiornare alla nuova versione come utente WordPress :in.

Introduzione a PHP 8 

PHP 8 è stato presentato per la prima volta ai tuoi tester alpha il 18 giugno 2020 ed è stato in un congelamento di funzionalità da luglio. Quindi non è stato permesso di aggiungere nuove aggiunte fino al rilascio del 26 novembre. Una caratteristica unica di questa release è che stiamo saltando PHP 7.5 e andiamo direttamente a PHP 8. E questo salto è dotato di un sacco di caratteristiche. 

Una delle domande più comuni su PHP 8 che gli utenti di WordPress probabilmente si pongono è: PHP 8 migliorerà le prestazioni del mio sito web?

La risposta a questa domanda è (come spesso accade): "Dipende...".

Quando PHP è stato aggiornato dalla versione 5 alla versione 7, le prestazioni sono aumentate notevolmente. Con PHP 8, tuttavia, non vedrai un miglioramento generale delle prestazioni a meno che la tua applicazione non calcoli molte funzioni matematiche (vedi la nostra sezione sul compilatore JIT). Questo è dovuto principalmente al fatto che l'ottimizzazione del codice di PHP è già molto consolidata.

Ma chi dice che le prestazioni sono limitate al tempo di compilazione? Per quanto mi riguarda, come sviluppatore, misuro le prestazioni in diversi modi, tra cui le funzioni a mia disposizione per scrivere codice ben strutturato. E PHP 8 è pieno di novità. Quindi, iniziamo!

Aggiornamenti delle funzionalità in PHP 8 

PHP 8 ha otto nuove caratteristiche principali che vorrei presentarti brevemente: 

1. Il compilatore JIT 
2. Attributi
3. Argomenti denominati
4. Abbinare le espressioni 
5. Espressioni di lancio
6. Tipo di ritorno statico 
7. Tipo di unione 
8. Tipi misti 

Il compilatore JIT (just-in-time)(rfc)

Quando il codice PHP viene eseguito, di solito viene fatto compilando in istruzioni virtuali che vengono eseguite su una macchina virtuale. JIT cambierà questo compilando il codice in codice macchina x86 e poi eseguendo quel codice direttamente sulla CPU. Per le applicazioni che si basano molto sulle funzioni matematiche, questo dovrebbe comportare un aumento delle prestazioni. Tuttavia, questo non è previsto per applicazioni web medie (vedi grafico). 

Per un esempio dei guadagni di prestazioni che si possono ottenere con JIT, è meglio guardare il video qui sotto.

Fondamentalmente, se stai usando PHP per un compito matematico impegnativo, la tua applicazione funzionerà più facilmente con la nuova versione. Ma se usate PHP come la maggior parte degli utenti di WordPress , non noterete molti cambiamenti. Spiego di più su cosa significa PHP 8 per i proprietari di siti web WordPress qui sotto. 

Passiamo alle nuove caratteristiche:

Attributi v2(rfc, rfc)

Una delle nuove caratteristiche di PHP 8 (che ha portato a molte discussioni nella comunità PHP) sono gli attributi - conosciuti come "annotazioni" in molti altri linguaggi. Gli attributi sostituiscono la necessità di memorizzare metadati con i docblock in PHP 8. Questo è ciò a cui si doveva ricorrere per dichiarare metadati per classi, metodi, funzioni e argomenti in modo strutturato. 

Come potete immaginare, usare i commenti al codice per applicare i metadati non era l'ideale, ma funzionava. Fortunatamente, ora non avremo questo problema. 

Gli attributi possono essere definiti con l'opzione Syntax #[...] dichiarato.

Ecco alcuni esempi tratti dalla RFC su come gli attributi possono essere applicati a diversi tipi di dati.

#[ExampleAttribute]
class Foo
{
    #[ExampleAttribute]
    public const FOO = 'foo';
 
    #[ExampleAttribute]
    public $x;
 
    #[ExampleAttribute]
    public function foo(#[ExampleAttribute] $bar) { }
}
 
$object = new #[ExampleAttribute] class () { };
 
#[ExampleAttribute]
function f1() { }
 
$f2 = #[ExampleAttribute] function () { };
 
$f3 = #[ExampleAttribute] fn () => 1;

A questo punto, vale la pena notare che l'RFC per gli attributi ha subito diversi cambiamenti dalla sua concezione originale, il che dimostra lo sforzo e il pensiero che sono stati fatti in questo aggiornamento. 

Argomenti denominati(rfc)

Gliargomenti con nome vi danno più flessibilità quando chiamate le funzioni. Fino ad ora, si doveva chiamare una funzione e passare ogni argomento nell'ordine specificato dalla funzione. 

// Using positional arguments:
array_fill(0, 100, 50);

Named Arguments permette di definire un nome per ogni parametro. E ora possono essere chiamati fuori dall'ordine, come descritto di seguito: 

// Using named arguments:
array_fill(start_index: 0, num: 100, value: 50);

È possibile accedervi anche come segue:

array_fill(value: 50, num: 100, start_index: 0);

Un ibrido dei due è anche possibile, permettendo di combinare parametri nominati e argomenti posizionali, migliorando la leggibilità del codice: 

htmlspecialchars($string, double_encode: false);

Espressioni di corrispondenza(rfc)

Match Expressions intende risolvere alcuni problemi di lunga data nella funzionalità del suo predecessore, Switch. 

operatore di confronto

Switch usa un operatore relazionale di conversione di tipo (==), che può causare problemi. Al contrario, Match usa un operatore di confronto rigoroso (===), indipendente da strict_types.

valore di ritorno

Le istruzioni di commutazione spesso creano un valore che è necessario più avanti nel flusso del programma. Può succedere che questo valore non sia impostato nell'istruzione switch, il che può successivamente portare a problemi nello script PHP. Inoltre, la sintassi dell'istruzione switch rende difficile la lettura delle istruzioni switch annidate.

switch (1) {
    case 0:
        $y = 'Foo';
        break;
    case 1:
        $y = 'Bar';
        break;
    case 2:
        $y = 'Baz';
        break;
}
 
echo $y;
//> Bar

La nuova espressione match elimina questo problema assegnando il valore di ritorno direttamente per ogni ramo match(=>), che è più intuitivo. 

echo match (1) {
    0 => 'Foo',
    1 => 'Bar',
    2 => 'Baz',
};
//> Bar

Passaggio di testimone

Se un'istruzione switch non ha una pausa dopo ogni caso, continuerà al caso successivo anche se il codice si interrompe. Questo è stato progettato per permettere alle funzioni di commutazione di eseguire più blocchi di codice in sequenza. Tuttavia, questa è stata una fonte comune di errori. 

Match ha implementato una pausa implicita dopo ogni ramo (=>). Le condizioni multiple possono ora essere eseguite mettendo delle virgole tra ogni condizione: 

match ($x) {
    1, 2 => {
        // Same for 1 and 2
    },
    3, 4 => {
        if ($x === 3) {
            // Only 3
        }
        // Same for 3 and 4
    },
}

Espressioni di lancio(rfc)

In PHP 8, l'istruzione throw è diventata un'espressione. Questo significa che throw può ora tecnicamente restituire un valore. Questo è utile nel senso che il lancio può essere utilizzato in molti altri punti, come ad esempio le Funzioni Freccia o gli Operatori Coalesce. 

Funzioni della freccia: 

$callable = fn() => throw new Exception();

Operatori Coalesce: 

// $value is non-nullable.
$value = $nullableValue ?? throw new InvalidArgumentException();
 
// $value is truthy.
$value = $falsableValue ?: throw new InvalidArgumentException();

Operatori ternari:

// $value is only set if the array is not empty.
$value = !empty($array)
    ? reset($array)
    : throw new InvalidArgumentException();

Tipo di ritorno statico(rfc)

Come afferma questa RFC, il tipo di ritorno statico consente di restituire il nome della classe speciale "static" da un metodo: "Il nome della classe speciale static in PHP si riferisce alla classe su cui è stato effettivamente chiamato un metodo, anche se il metodo è ereditato. Questo fenomeno è noto come "late static binding" (LSB). Questa RFC propone di rendere static utilizzabile anche come tipo di ritorno (accanto ai tipi self e parent già utilizzabili)".

Tuttavia, in questo caso non è possibile utilizzare il termine statico come parte di un parametro. Il ritorno statico farà riferimento alla classe che è stata chiamata. 

Tipi di Unione(rfc)

Tipi di Unione vi permettono di dichiarare il tipo di valore che vi aspettate da un input. In alcuni linguaggi, questo è chiamato schema. Questo è fatto sintatticamente usando  | (es. string|array|int) definito. Ma la magia non si ferma qui, perché si possono anche usare classi definite come:

class MyClass {

}

function myFunction(string|array|int|MyClass){

}

I tipi unionali sono già usati in PHP. Tuttavia, sono implementati usando il metodo delle annotazioni phpdoc, come mostrato qui sotto. 

class Number {
    /**
     * @var int|float $number
     */
    private $number;
 
    /**
     * @param int|float $number
     */
    public function setNumber($number) {
        $this->number = $number;
    }
 
    /**
     * @return int|float
     */
    public function getNumber() {
        return $this->number;
    }
}

Per maggiori informazioni sull'utilizzo, dai un'occhiata a questo esempio tratto dall'RFC:

class Number {
    private int|float $number;
 
    public function setNumber(int|float $number): void {
        $this->number = $number;
    }
 
    public function getNumber(): int|float {
        return $this->number;
    }
}

Tutto questo si riduce al fatto che puoi utilizzare più tipi di input per la stessa funzione invece di uno solo, il che consente un maggior grado di riutilizzo del codice.

Tipi misti(rfc)

Nelle ultime versioni di PHP, era possibile dichiarare il tipo atteso di dati di input e di ritorno. Tuttavia, PHP non ha sempre supportato i tipi, e questo è un problema. In alcuni casi, un Tipo è stato omesso o semplicemente dimenticato. MixedTypes cerca ora di risolvere questo problema.

Un mixed sarebbe l'equivalente di array|bool|callable|int|float|null|object|resource|string

Ecco un esempio tratto dalla documentazione RFC di come viene utilizzato:

// Valid example
 
class A
{
    public function foo(int $value) {}
}
 
class B extends A
{
    // Parameter type was widened from int to mixed, this is allowed
    public function foo(mixed $value) {}
}

Caratteristiche aggiuntive di PHP 8

Rendi stabile l'ordinamento(rfc)

La stabilità viene aggiunta a tutte le funzioni che rientrano in Sort (ad esempio.

sort, rsort, usort, asort, arsort, uasort, ksort, krsort, uksort, array_multisort).

Ti consiglio di leggere la documentazione RFC e di confrontarla con la tua applicazione, poiché la modifica di questa funzionalità dall'ordinamento instabile a quello stabile potrebbe influire negativamente sul tuo codice.

Promozione della proprietà del costruttore(rfc)

Questa funzione dovrebbe aiutarti a velocizzare il tuo flusso di lavoro di sviluppo e a ridurre gli errori. Attualmente, la definizione di un oggetto di valori richiede una serie di boilerplate, come mostrato di seguito nella documentazione RFC:

class Point {
    public float $x;
    public float $y;
    public float $z;
 
    public function __construct(
        float $x = 0.0,
        float $y = 0.0,
        float $z = 0.0,
    ) {
        $this->x = $x;
        $this->y = $y;
        $this->z = $z;
    }
}

In questo metodo, le proprietà devono essere ripetute tre volte. Il miglioramento è rappresentato dalla formula breve riportata di seguito: 

class Point {
    public function __construct(
        public float $x = 0.0,
        public float $y = 0.0,
        public float $z = 0.0,
    ) {}
}

Operatore sicuro zero(rfc)

C'è un nuovo operatore in questo blocco! 

Anstelle des klassischen <code>!== null</code> haben wir nun das bekommen: <code>?-></code>. Es scheint zunächst merkwürdig, aber wenn man es unter dem Gesichtspunkt der Verkettung von „if-Statements“ betrachtet, dann wird die Anwendung ziemlich deutlich: 

$country =  null;
 
if ($session !== null) {
    $user = $session->user;
 
    if ($user !== null) {
        $address = $user->getAddress();
 
        if ($address !== null) {
            $country = $address->country;
        }
    }
}
 
// do something with $country

$country = $session?->user?->getAddress()?->country;
 
// do something with $country

str_contains(rfc)

Questa nuova funzione piuttosto carina restituisce un valore booleano (vero/falso) se una stringa si trova in un'altra stringa. Prende due argomenti, la stringa da cercare e la stringa da cercare.

str_contains('php8', '8'); // true

str_contains('php8', 'wordpress'); // false

Per ottenere filtri di stringa ancora più utili, dai un'occhiata a queste nuove funzioni:

str_starts_with('haystack', 'hay'); // true
str_ends_with('haystack', 'stack'); // true

Questi due restituiscono entrambi un risultato booleano e funzionano allo stesso modo di str_contains().

Mappe deboli(rfc)

In PHP, quando si imposta una variabile al valore di un oggetto, di solito si crea un riferimento a quell'oggetto, ma non un nuovo oggetto. 

Quindi, in questo caso, si può finire per avere molti riferimenti a un oggetto, ma un solo oggetto. Il problema con questo è: quando arriva il momento di cancellare quell'oggetto, PHP conterà il numero di riferimenti che quell'oggetto ha. E se è più di uno, PHP si rifiuta di cancellare quell'oggetto. 

Weak Maps risolve questo problema creando un riferimento "debole" all'oggetto corrispondente. Non appena l'oggetto viene cancellato, tutte le variabili con il riferimento Weak Maps a questo oggetto vengono azzerate. 

Catture non catturanti(rfc)

Un blocco try-catch è già abbastanza fantastico per quanto riguarda la segnalazione degli errori e ora c'è un modo ancora più veloce per implementarlo. E no, questo non influisce sulla leggibilità. 

Il metodo della "vecchia scuola" prevedeva che dovessi passare l'eccezione catch a una variabile come questa:

function catchMeWhenIFall(){
	try {
        throw new Exception('NOPE - GRAVITY');
    } catch (Exception $e) {
        return $e->getMessage();
    }

}

Ma ora non hai bisogno di definire la variabile da passare al vostro blocco catch.

try {
	throw new Exception('FOO!');
 catch  (){
	//Do some code here
 }

}

Ulteriori letture di PHP 8

Se vuoi saperne di più sul rilascio di PHP 8 o controllare i campioni di codice RFC per te stesso, dai un'occhiata all'annuncio ufficiale del rilascio. 

Sei pronto per PHP 8? 

Nessuno sviluppatore è un fan degli aggiornamenti con grandi cambiamenti (ricordiamo WordPress 5.0 e Gutenberg), dove c'è il rischio che il vostro codice si rompa e vi aspettano ore di lavoro o una ricostruzione completa. Comunque, se il tuo codice ha funzionato bene con PHP 7.4, non dovresti avere problemi con PHP 8 (maggiori informazioni su PHP e WordPress nel prossimo capitolo). 

Tuttavia, se stai usando una vecchia versione di PHP, dovresti controllare la lista delle caratteristiche deprecate prima di aggiornare. Vedi la documentazione "Appendici" di PHP per una lista completa delle caratteristiche precedenti, dei cambiamenti e dei problemi quando si aggiorna da una versione di PHP alla successiva. 

Aggiornare WordPress a PHP 8? 

Questa citazione tratta dal"Rapporto sulla compatibilità di WordPress e PHP 8" di Yoast suggerisce già che tu, in quanto utente di WordPress, non dovresti trattare l'aggiornamento a PHP 8 con leggerezza. La conclusione del rapporto rafforza questa ipotesi, come scrive Omar Reiss: "Analizzando solo un sottoinsieme di modifiche di rottura in PHP 8 abbiamo già potuto confermare che è probabile che queste causino gravi rotture su siti con un'origine non chiara di tali rotture. Spesso l'errore si verifica in un punto, ma è causato da un plugin o da un tema in un punto diverso, rendendo questi problemi difficili da debuggare".

Questi problemi di compatibilità sono stati anche il motivo per cui PHP 8 non è stato immediatamente disponibile per i nostri clienti. Soprattutto dopo gli aggiornamenti più importanti, è sempre opportuno dare agli sviluppatori dei plugin di WordPress il tempo necessario per apportare eventuali modifiche e aspettare. Ora puoi aggiornare facilmente il tuo sito web a PHP 8 o PHP 8.1 tramite Raidboxes Dashboard . Come testare correttamente una nuova versione di PHP su Raidboxes è spiegato in questo articolo dell'Helpcenter.

Le nostre conclusioni su PHP 8

PHP 8 è un grande passo avanti rispetto ai tuoi predecessori. Mentre potresti non vedere subito un drammatico miglioramento delle prestazioni (a seconda di come usi PHP 8), dovresti considerare l'aggiornamento - almeno dopo averlo testato, dopo che è stabile ed è disponibile dal tuo host WordPress . La nuova versione è una progressione naturale, e implementandola prima piuttosto che dopo, getterete una solida base per i futuri miglioramenti, la crescita e le prestazioni future.