PHP 8 - Nuove caratteristiche, miglioramenti e potenziali problemi con WordPress

Marten Gülink Ultimo aggiornamento 11.01.2021
10 Min.
php 8 major update
Ultimo aggiornamento 11.01.2021


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 suoi 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, c'è stato un enorme aumento delle prestazioni. 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 è principalmente perché l'ottimizzazione del codice di PHP è già molto ben stabilita.

Ma chi dice che le prestazioni si limitano al tempo di compilazione? Io per primo, come sviluppatore, misurerei le prestazioni in diversi modi, comprese le caratteristiche a mia disposizione per scrivere codice ben strutturato. E PHP 8 è pieno di nuove chicche. Allora, cominciamo!

I più importanti aggiornamenti di nuove funzionalità in PHP 8 

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

  1. Il compilatore JIT 
  2. Attributi
  3. Argomenti nominati
  4. Espressioni di corrispondenza 
  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). 

PHP 8 - Nuove caratteristiche, miglioramenti e potenziali problemi con WordPress
Fonte

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

YouTube

Caricando il video, accetti l'informativa sulla privacy di YouTube.
Per saperne di più

Carica il video

PGlmcmFtZSBzcmM9Imh0dHBzOi8vd3d3LnlvdXR1YmUtbm9jb29raWUuY29tL2VtYmVkL2RXSDY1cG1uc3JJIiBhbGxvdz0iYWNjZWxlcm9tZXRlcjsgYXV0b3BsYXk7IGNsaXBib2FyZC13cml0ZTsgZW5jcnlwdGVkLW1lZGlhOyBneXJvc2NvcGU7IHBpY3R1cmUtaW4tcGljdHVyZSIgYWxsb3dmdWxsc2NyZWVuPSIiIHdpZHRoPSI1NjAiIGhlaWdodD0iMzE1IiBmcmFtZWJvcmRlcj0iMCI+PC9pZnJhbWU+

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'attributo Syntax #[...] dichiarato.

Ecco alcuni esempi dalla RFC di 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 nominati(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);

Si può anche accedervi 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 è destinato a 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

Fallthrough

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, la dichiarazione di lancio è diventata un'espressione. Questo significa che il lancio può ora tecnicamente restituire un valore. Questo è utile nel senso che il lancio può ora essere usato in molti più posti, come le funzioni Arrow o gli operatori Coalesce. 

Funzioni di freccia: 

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

Coalizzare gli operatori: 

// $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 questo RFC, Static Return Type permette la restituzione del nome speciale di classe "static" da un metodo: "Il nome speciale di classe statica in PHP si riferisce alla classe su cui un metodo è stato effettivamente chiamato, anche se il metodo è ereditato. Questo è 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)".

Static non può essere usato come parte di un parametro in questo caso, tuttavia. 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 un po' più di contesto sull'uso, guardate questo esempio dalla 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 si possono usare più tipi di input per la stessa funzione invece di uno solo, il che permette un maggior grado di riusabilità 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 dalla documentazione RFC di come viene usato:

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

Rendere stabile l'ordinamento(rfc)

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

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

Vi raccomanderei di leggere questo nella documentazione RFC e di confrontarlo con la vostra applicazione, poiché cambiare questa funzionalità dall'ordinamento instabile a quello stabile potrebbe avere un impatto negativo sul vostro codice.

Promozione della proprietà del costruttore(rfc)

Questa caratteristica dovrebbe aiutare a velocizzare il vostro flusso di lavoro di sviluppo e a ridurre gli errori. Attualmente, definire un oggetto di valori richiede un insieme 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 di questo è la breve formula qui sotto: 

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! 

Invece del classico <code>!== null</code>, ora abbiamo questo: <code>?->.</code> Sembra strano all'inizio, ma se lo si guarda dal punto di vista della concatenazione di "if-statements", l'applicazione diventa abbastanza chiara: 

$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 filtri di stringhe ancora più utili, controlla queste nuove caratteristiche:

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. Una volta che l'oggetto è cancellato, tutte le variabili con il riferimento Weak Maps a quell'oggetto sono impostate a zero. 

Catture non catturanti(rfc)

Un blocco try-catch è già abbastanza impressionante quando si tratta di segnalare gli errori e ora c'è un modo ancora più veloce per implementarlo. E no, questo non influenzerà davvero la leggibilità. 

Il modo "vecchia scuola" significava che dovevate passare la vostra eccezione di cattura a una variabile come questa:

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

}

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

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

}

Ulteriore materiale di lettura 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. 

Dovresti aggiornare il tuo WordPress a PHP 8? 

Per i codici ben compilati o i codici che sono stati aggiornati con le ultime versioni di PHP, non c'è un grande problema [per migrare a PHP 8]. La realtà, tuttavia, è che WordPress non è un tale codebase.

Omar Reiss, yoast

Questa citazione da Yoast "WordPress and PHP 8 Compatibility Report" suggerisce già che tu come utente di WordPress non dovresti trattare l'aggiornamento a PHP 8 alla leggera. La conclusione del rapporto rafforza questa ipotesi, come scrive Omar Reiss: "Indagando solo su un sottoinsieme di cambiamenti di rottura in PHP 8 potremmo già confermare che è probabile che questo causi rotture importanti sui siti con un'origine non chiara di tali rotture. Spesso l'errore si verifica in un posto, ma è causato da un plugin o theme in un posto diverso, rendendo questi problemi difficili da risolvere".

Questi problemi di compatibilità sono anche una ragione per cui PHP 8 non è immediatamente disponibile per i nostri clienti in RAIDBOXES dashboard . Soprattutto dopo i grandi aggiornamenti, ha sempre senso dare agli sviluppatori di Plugin abbastanza tempo per eventuali aggiustamenti e aspettare per il momento. Non appena saremo sicuri che non ci sono problemi con un'installazione standard di WordPress e che PHP 8 funziona in modo stabile e performante sul nostro sistema, renderemo ovviamente disponibile PHP 8.

Se hai già accesso a PHP 8 e vuoi testare la nuova versione con il tuo sito WordPress , dovresti - come prima di ogni aggiornamento - creare prima un backup. Come testare correttamente una nuova versione di PHP su RAIDBOXES può essere letto in questo articolo dell'Helpcenter (qui usando PHP 7.2 come esempio).

La nostra conclusione

PHP 8 è un grande passo avanti rispetto ai suoi 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.

Altre domande su PHP 8?

Spero di essere stato in grado di introdurvi alle nuove entusiasmanti caratteristiche di PHP 8 con questo articolo. Hai altre domande sull'argomento? Sentitevi liberi di usare la funzione di commento. Vuoi altri consigli su WordPress , web design e altro? Allora seguici su Twitter, Facebook o tramite la nostra newsletter.

Come sviluppatore web a RAIDBOXES Marten lavora sempre su nuove funzionalità per i nostri clienti. In "wp unboxed" segna anche con le sue conoscenze sullo sviluppo web, WordPress e il nostro dashboard. E anche nel suo tempo libero gli piace occuparsi di self-hosting e delle ultime tendenze su Internet.

Commenti su questo articolo

Scrivi un commento

Il tuo indirizzo e-mail non sarà pubblicato. I campi obbligatori sono contrassegnati con *.