PHP 7.4, la pi\u00f9 recente minor release di PHP 7, \u00e8 stato rilasciato alla General Availability il 28 novembre 2019. Quindi \u00e8 il momento per noi di analizzare alcune delle novit\u00e0 e delle funzionalit\u00e0 pi\u00f9 interessanti che rendono PHP pi\u00f9 veloce e affidabile.<\/p>\n
Aggiornamento:<\/strong> PHP 8.1 (versione ufficiale)<\/a> \u00e8 ora disponibile per tutti i clienti Kinsta. Kinsta non supporta pi\u00f9 PHP 7.4. Supportiamo invece le versioni di PHP 7.4, 8.0, 8.1, 8.2, 8.3, 8.4 e 8.5.<\/p>\n Anche se PHP 7.4 migliora significativamente le prestazioni e la leggibilit\u00e0 del codice, PHP 8<\/a> sar\u00e0 la vera pietra miliare per le prestazioni di PHP, poich\u00e9 la proposta di inclusione di JIT<\/a> \u00e8 gi\u00e0 stata approvata.<\/p>\n Ad ogni modo, oggi analizzeremo insieme alcune delle funzionalit\u00e0 e delle modifiche pi\u00f9 interessanti che ci attendiamo da PHP 7.4. Giusto per registrazione, queste sono state le date importanti che hanno portato al rilascio di PHP 7.4::<\/p>\n Potete trovare l’elenco completo delle funzionalit\u00e0 e delle novit\u00e0 nella pagina ufficiale della RFC<\/a>.<\/p>\n In questo post analizziamo diverse novit\u00e0 e funzionalit\u00e0 aggiunte al linguaggio con il rilascio definitivo di PHP 7.4:<\/p>\n Disponibile a partire da PHP 5.6, lo spacchettamento degli argomenti<\/a> \u00e8 una sintassi che permette di decomprimere array e Traversables<\/a> in elenchi di argomenti. Per decomprimere un array o un Traversable, \u00e8 necessario anteporvi … (3 punti), come mostrato nell’esempio che segue:<\/p>\n Ora, questa RFC di PHP 7.4<\/a> propone di estendere questa funzionalit\u00e0 alle definizioni degli array:<\/p>\n Il primo vantaggio dichiarato dello Spread Operator nell’espressione dell’array<\/strong> riguarda le prestazioni. Infatti, il documento dell’RFC afferma<\/a>:<\/p>\n Lo Spread Operator dovrebbe avere prestazioni migliori rispetto a Un vantaggio significativo dello Spread Operator \u00e8 che supporta qualsiasi oggetto traversable, mentre la funzione Ecco un esempio di spacchettamento degli argomenti nell’espressione di array:<\/p>\n Se si dovesse eseguire questo codice con PHP 7.3 o versioni precedenti, PHP genererebbe un Parse error:<\/p>\n Invece PHP 7.4 restituisce un array:<\/p>\n L’RFC afferma che possiamo espandere lo stesso array pi\u00f9 volte. Inoltre, possiamo utilizzare la sintassi dello Spread Operator ovunque nell’array, dato che \u00e8 possibile aggiungere elementi normali prima o dopo lo Spread Operator. Per questo, il codice che segue funzioner\u00e0 nel modo in cui potremmo aspettarci:<\/p>\n \u00c8 anche possibile decomprimere gli array restituiti da una funzione direttamente in un nuovo array:<\/p>\n PHP 7.4 produce il seguente array:<\/p>\n Possiamo anche utilizzare la generator syntax<\/a>:<\/p>\n Tuttavia non possiamo decomprimere gli array passati per riferimento (by reference<\/em>). Considerate il seguente esempio:<\/p>\n Se provassimo a decomprimere un array per riferimento, PHP genererebbe il seguente Parse error:<\/p>\n Ad ogni modo, se gli elementi del primo array sono memorizzati per riferimento, saranno memorizzati per riferimento anche nel secondo array. Ecco un esempio:<\/p>\n Ed ecco cosa otteniamo con PHP 7.4:<\/p>\n La proposta dello Spread Operator \u00e8 stata approvata con 43 voti favorevoli contro 1.<\/p>\n In PHP, le funzioni anonime<\/a> sono considerate piuttosto prolisse e difficili da implementare e mantenere. Questa RFC<\/a> propone l’introduzione di una sintassi pi\u00f9 sintetica e pi\u00f9 chiara per le arrow functions<\/strong> (o short closures<\/em>), che dovrebbe permetterci di ripulire in modo significativo il nostro codice PHP.<\/p>\n Considerate il seguente esempio:<\/p>\n PHP 7.4 permette di utilizzare una sintassi pi\u00f9 concisa, e la funzione qui sopra potrebbe essere riscritta come segue:<\/p>\n Attualmente, le funzioni anonime<\/a> (closure<\/em>) possono ereditare variabili definite nello scopo superiore (parent scope<\/em>) grazie al costrutto di linguaggio Ma con PHP 7.4, le variabili definite nel parent scope sono catturate implicitamente per valore<\/strong> (implicit by-value scope binding<\/em>). Possiamo, quindi, scrivere l’intera funzione vista sopra su una singola riga:<\/p>\n La variabile definita nel parent scope<\/em> pu\u00f2 essere utilizzata nella arrow function esattamente come se stessimo utilizzando La nuova sintassi rappresenta un notevole miglioramento del linguaggio in quanto ci consente di creare codice pi\u00f9 leggibile e gestibile. Possiamo anche utilizzare parametri e tipi di ritorno<\/a>, valori predefiniti, liste di argomenti a lunghezza variabile (funzioni variadiche<\/a>), possiamo passare e restituire per riferimento, ecc. Infine, le short closure<\/em> possono essere utilizzate anche in metodi di classe e possono fare uso della variabile Questa RFC \u00e8 stata approvata con 51 voti favorevoli contro 8.<\/p>\n Aggiunto con PHP 7, l’operatore di coalescenza<\/a> ( Questo codice fa una cosa piuttosto semplice: recupera il parametro della richiesta e imposta un valore predefinito nel caso in cui questo non esista<\/strong>. Il significato di questa riga di codice \u00e8 chiaro, ma cosa accadrebbe se avessimo nomi di variabili molto pi\u00f9 lunghi, come in questo esempio della RFC?<\/p>\n Nel lungo termine, questo codice potrebbe essere un po’ difficile da mantenere. Quindi, con l’obiettivo di aiutare gli sviluppatori a scrivere codice pi\u00f9 intuitivo, questa RFC<\/a> propone l’introduzione dell’operatore di assegnazione null coalesce<\/strong> ( Se il valore del parametro di sinistra \u00e8 Questa proposta \u00e8 stata approvata con 37 voti favorevoli e 4 contrari.<\/p>\n Le dichiarazioni del tipo dell’argomento, o type hint, consentono di specificare il tipo di una variabile che si prevede venga passata a una funzione o a un metodo di classe. I type hint<\/em> sono disponibili sin da PHP 5 e, a partire da PHP 7.2<\/a>, li possiamo utilizzare con il tipo di dati Sono supportati tutti i tipi, ad eccezione di La RFC spiega il motivo per cui Il tipo void non \u00e8 supportato perch\u00e9 non \u00e8 utile e ha una semantica poco chiara.<\/p><\/blockquote>\n Il tipo callable non \u00e8 supportato perch\u00e9 il suo comportamento dipende dal contesto.<\/p><\/blockquote>\n Quindi possiamo tranquillamente usare I tipi possono essere utilizzati su propriet\u00e0 statiche:<\/p>\n Sono inoltre ammessi con la notazione \u00c8 possibile impostare valori di propriet\u00e0 predefiniti, che ovviamente devono corrispondere al tipo di propriet\u00e0 dichiarato, ma solo le propriet\u00e0 nullable possono avere Lo stesso tipo si applica a tutte le propriet\u00e0 di una singola dichiarazione:<\/p>\n Cosa succede se commettiamo un errore sul tipo di propriet\u00e0? Consideriamo il seguente codice:<\/p>\n Nel codice qui sopra, abbiamo dichiarato un tipo di propriet\u00e0 string, ma abbiamo impostato un array come valore della propriet\u00e0. In tale situazione, otteniamo il seguente Fatal error:<\/p>\n Questa RFC \u00e8 stata approvata con 70 voti contro 1.<\/p>\n\n Con questa RFC<\/a>, PHP 7.4 introduce la classe WeakReference<\/a>, che consente ai programmatori di mantenere un riferimento a un oggetto che non impedisce che l’oggetto stesso venga distrutto.<\/p>\n Attualmente PHP supporta le Weak References con il ricorso ad un’estensione come pecl-weakref. Ad ogni modo, la nuova API \u00e8 diversa dalla classe Ecco un esempio dell’autore di questa proposta<\/a>, Nikita Popov:<\/p>\n Il primo Slides for my PHP 7.4 talk at #PHPRussia2019<\/a>. Was a great conference!https:\/\/t.co\/zLr9Bj2aKl<\/a><\/p>\n — Nikita Popov (@nikita_ppv) May 19, 2019<\/a><\/p><\/blockquote>\n\n
Cosa c’\u00e8 di nuovo in PHP con PHP 7.4?<\/h2>\n
Dimenticatevi di array_merge: PHP 7.4 Porta lo Spread Operator nell’Espressione degli Array<\/h3>\n
function test(...$args) { var_dump($args); }\ntest(1, 2, 3);<\/code><\/pre>\n$arr = [...$args];<\/code><\/pre>\narray_merge<\/code>. Questo non solo perch\u00e9 lo Spread Operator \u00e8 una struttura del linguaggio mentre array_merge<\/code> \u00e8 una chiamata di funzione, ma anche perch\u00e9 l’ottimizzazione del tempo di compilazione pu\u00f2 essere performante per gli array di costanti.<\/p><\/blockquote>\narray_merge<\/code> supporta solo gli array.<\/p>\n$parts = ['apple', 'pear'];\n$fruits = ['banana', 'orange', ...$parts, 'watermelon'];\nvar_dump($fruits);<\/code><\/pre>\nParse error: syntax error, unexpected '...' (T_ELLIPSIS), expecting ']' in \/app\/spread-operator.php on line 3<\/code><\/pre>\narray(5) {\n\t[0]=>\n\tstring(6) \"banana\"\n\t[1]=>\n\tstring(6) \"orange\"\n\t[2]=>\n\tstring(5) \"apple\"\n\t[3]=>\n\tstring(4) \"pear\"\n\t[4]=>\n\tstring(10) \"watermelon\"\n}<\/code><\/pre>\n$arr1 = [1, 2, 3];\n$arr2 = [4, 5, 6];\n$arr3 = [...$arr1, ...$arr2];\n$arr4 = [...$arr1, ...$arr3, 7, 8, 9];<\/code><\/pre>\nfunction buildArray(){\n\treturn ['red', 'green', 'blue'];\n}\n$arr1 = [...buildArray(), 'pink', 'violet', 'yellow'];<\/code><\/pre>\narray(6) {\n\t[0]=>\n\tstring(3) \"red\"\n\t[1]=>\n\tstring(5) \"green\"\n\t[2]=>\n\tstring(4) \"blue\"\n\t[3]=>\n\tstring(4) \"pink\"\n\t[4]=>\n\tstring(6) \"violet\"\n\t[5]=>\n\tstring(6) \"yellow\"\n}<\/code><\/pre>\nfunction generator() {\n\tfor ($i = 3; $i <= 5; $i++) {\n\t\tyield $i;\n\t}\n}\n$arr1 = [0, 1, 2, ...generator()];<\/code><\/pre>\n$arr1 = ['red', 'green', 'blue'];\n$arr2 = [...&$arr1];<\/code><\/pre>\nParse error: syntax error, unexpected '&' in \/app\/spread-operator.php on line 3<\/code><\/pre>\n$arr0 = 'red';\n$arr1 = [&$arr0, 'green', 'blue'];\n$arr2 = ['white', ...$arr1, 'black'];<\/code><\/pre>\narray(5) {\n\t[0]=>\n\tstring(5) \"white\"\n\t[1]=>\n\t&string(3) \"red\"<\/strong>\n\t[2]=>\n\tstring(5) \"green\"\n\t[3]=>\n\tstring(4) \"blue\"\n\t[4]=>\n\tstring(5) \"black\"\n}<\/code><\/pre>\nArrow Functions 2.0 (Short Closures)<\/h3>\n
function cube($n){\n\treturn ($n * $n * $n);\n}\n$a = [1, 2, 3, 4, 5];\n$b = array_map('cube', $a);\nprint_r($b);<\/code><\/pre>\n$a = [1, 2, 3, 4, 5];\n$b = array_map(fn($n) => $n * $n * $n, $a);\nprint_r($b);<\/code><\/pre>\nuse<\/code>, come mostrato di seguito:<\/p>\n$factor = 10;\n$calc = function($num) use($factor){\n\treturn $num * $factor;\n};<\/code><\/pre>\n$factor = 10;\n$calc = fn($num) => $num * $factor;<\/code><\/pre>\nuse($var)<\/code>, e non \u00e8 possibile modificare una variabile dal parent scope.<\/p>\n$this<\/code> esattamente come le normali closure.<\/p>\nOperatore di Assegnazione di Coalescenza Nulled<\/h3>\n
??<\/code>) \u00e8 utile quando abbiamo bisogno di un operatore ternario insieme a isset()<\/code>. Questo restituisce il primo operando, se questo esiste e non \u00e8 NULL<\/code>. In caso contrario, restituisce il secondo operando. Ecco un esempio:<\/p>\n$username = $_GET['user'] ?? 'nobody';<\/code><\/pre>\n$this->request->data['comments']['user_id'] = $this->request->data['comments']['user_id'] ?? 'value';<\/code><\/pre>\n??=<\/code>). Quindi, invece di scrivere il codice precedente, potremmo scrivere quanto segue:<\/p>\n$this->request->data['comments']['user_id'] ??= 'value';<\/code><\/pre>\nnull<\/code>, viene utilizzato il valore del parametro di destra.
\nSi noti che, mentre l’operatore di coalescenza \u00e8 un operatore di confronto, ??=<\/code> \u00e8 un operatore di assegnazione.<\/p>\nTyped Properties 2.0<\/h3>\n
object<\/code>. Ora PHP 7.4 spinge il type hinting<\/em> un passo avanti, aggiungendo il supporto per le dichiarazioni del tipo di propriet\u00e0 di prima classe<\/a>. Ecco un esempio molto semplice:<\/p>\nclass User {\n\tpublic int $id;\n\tpublic string $name;\n}<\/code><\/pre>\nvoid<\/code> e callable<\/code>:<\/p>\npublic int $scalarType;\nprotected ClassName $classType;\nprivate ?ClassName $nullableClassType;<\/code><\/pre>\nvoid<\/code> e callable<\/code> non sono supportati:<\/p>\nbool<\/code>, int<\/code>, float<\/code>, string<\/code>, array<\/code>, object<\/code>, iterable<\/code>, self<\/code>, parent<\/code>, qualsiasi nome di classe o di interfaccia e i nullable<\/a> types<\/a> (?type<\/code>).<\/p>\npublic static iterable $staticProp;<\/code><\/pre>\nvar<\/code>:<\/p>\nvar bool $flag;<\/code><\/pre>\nnull<\/code> come valore predefinito:<\/p>\npublic string $str = \"foo\";\npublic ?string $nullableStr = null;<\/code><\/pre>\npublic float $x, $y;<\/code><\/pre>\nclass User {\n\tpublic int $id;\n\tpublic string $name;\n}\n\n$user = new User;\n$user->id = 10;\n$user->name = [];<\/code><\/pre>\nFatal error: Uncaught TypeError: Typed property User::$name must be string, array used in \/app\/types.php:9<\/code><\/pre>\nWeak References<\/h3>\n
WeakRef<\/code> documentata.<\/p>\n$object = new stdClass;\n$weakRef = WeakReference::create($object);\n\nvar_dump($weakRef->get());\nunset($object);\nvar_dump($weakRef->get());<\/code><\/pre>\nvar_dump<\/code> stampa object(stdClass)#1 (0) {}<\/code>, mentre il secondo var_dump<\/code> stampa NULL<\/code>, dato che l’oggetto di riferimento \u00e8 stato distrutto.<\/p>\n\n