Cosa aspettarsi da PHP 5.5

Il primo alfa PHP 5.5 è stato rilasciato pubblicamente. Dopo aver avuto un po 'di tempo per testare e sperimentare, possiamo ora fornirti una panoramica approfondita su cosa aspettarci!


Installazione

Se desideri seguire questo articolo, devi installare PHP 5.5 per te stesso. Puoi trovare il link al pacchetto sorgente qui. Inoltre, se hai bisogno del file binario di Windows, puoi recuperarlo dalla stessa pagina.

Una volta scaricato il codice sorgente, estrai tutto in una cartella e naviga con il tuo programma Terminale preferito. Puoi installare PHP ovunque ti piaccia, ma, per comodità, creerò una directory nella root della mia unità, chiamata PHP5.5. Per creare una nuova cartella e quindi rendere il tuo utente il proprietario di detta cartella, digita quanto segue nel tuo terminale:

 sudo mkdir /PHP5.5 sudo chown username /PHP5.5

Successivamente, devi decidere quali estensioni e funzionalità vuoi installare con la tua copia di PHP. Dal momento che questa è una versione Alpha, pensata solo per i test, non mi preoccuperò di renderla pienamente disponibile. Per questo tutorial, sto solo installando cURL, ma potrebbero esserci altre cose che vorresti aggiungere, come MySQL o il supporto per zip. Per visualizzare un elenco completo di opzioni di configurazione, esegui:

 ./ configure -h

Oltre all'opzione di installare cURL, ci sono altre due proprietà che dobbiamo impostare: il prefisso e con-config-file-path opzione. Queste due proprietà impostano la posizione dell'installazione di PHP e il .ini file, rispettivamente. Quindi nel terminale, digita:

 ./ configure --prefix = / PHP5.5 --with-config-file-path = / PHP5.5 --with-curl = ext / curl make make install

La prima riga configura PHP con cURL e imposta la posizione nella cartella creata in precedenza. Le prossime due linee costruiscono PHP e spostano i file nella directory specificata. Il prossimo passo è copiare il campione php.ini file nella cartella PHP. Per fare ciò, esegui:

 cp php.ini-development /PHP5.5/php.ini

Ora dovresti avere tutto installato correttamente. Il modo più semplice per provare questa nuova versione è eseguire il suo web server integrato. Vai a bidone cartella all'interno del PHP5.5 directory (cd /PHP5.5/bin), e digitare ./ php -t / Path / To / Directory -S 0.0.0.0:4444.

  • Il -t opzione imposta la directory root del server (cioè la posizione in cui posizionerai i tuoi file PHP)
  • Il -S la proprietà imposta l'indirizzo IP e il numero di porta a cui il server deve collegarsi. utilizzando 0.0.0.0 per l'indirizzo IP dice al server di ascoltare su tutti gli indirizzi IP (ad esempio localhost, 127.0.0.1, 192.168.0.100, ecc.).

Se tutto va bene, dovresti essere accolto con un messaggio che ti dice che il server è in ascolto sull'IP / porta specificata, e ti dirà la radice del documento da dove viene servito. Ora possiamo iniziare a giocare con le nuove funzionalità!


generatori

I generatori consentono di creare funzioni personalizzate, che mantengono lo stato tra le esecuzioni.

La più grande aggiunta a PHP 5.5 deve essere i generatori. I generatori consentono di creare funzioni personalizzate, che mantengono lo stato tra le esecuzioni. Funziona con una nuova parola chiave, chiamata dare la precedenza, che può essere utilizzato in una funzione sia per l'immissione che per l'emissione di dati.

Essenzialmente, quando la funzione arriva a una riga che contiene il comando yield, PHP bloccherà l'esecuzione della funzione e tornerà a eseguire il resto del programma. Quando chiedi che la funzione continui - o dicendogli di andare avanti o inviandogli dei dati - PHP tornerà alla funzione e riprenderà da dove era stata interrotta, preservando i valori di tutte le variabili locali che erano definite fino a lì.

All'inizio questo potrebbe sembrare un po 'fico, ma se ci pensi, questo apre le porte a molte opzioni di design interessanti. Innanzitutto, simula gli effetti di altri linguaggi di programmazione con "Valutazione pigra", come Haskell. Solo questo consente di definire insiemi di dati infiniti e modellare le funzioni matematiche dopo la loro effettiva definizione. Oltre a ciò, non devi creare il maggior numero di variabili globali; se una variabile è pensata solo per una funzione specifica, puoi includerla in un generatore e cose come i contatori avvengono automaticamente dal generatore stesso nella forma della chiave dell'oggetto restituito.

Bene, questa è una teoria sufficiente per ora; diamo un'occhiata a un generatore in azione. Per iniziare, vai alla radice del documento che hai definito durante l'esecuzione del server PHP e crea un file, chiamato "index.php". Ora apri il file e digita quanto segue:

 function fibonacci () $ a = 0; $ b = 1; while (true) $ a = $ a + $ b; $ b = $ a - $ b; cedere $ a; 

Questa è la funzione "Hello World" di set di dati infiniti. È una funzione che emetterà tutti i numeri di Fibonacci. Per utilizzare il generatore, tutto ciò che devi fare è digitare:

 $ fib = fibonacci (); $ Fib-> corrente (); $ Fib-> next (); $ Fib-> corrente (); // ... 

Quello che sta succedendo qui è che stiamo facendo $ fib un oggetto generatore, e quindi hai accesso ai comandi sottostanti, come attuale() e Il prossimo(). Il attuale() la funzione restituisce il valore corrente del generatore; questo è il valore di qualsiasi cosa tu abbia ceduto nella funzione, nel nostro caso, $ un. Puoi chiamare questa funzione più volte e otterrai sempre lo stesso valore, perché il attuale() la funzione non dice al generatore di continuare a valutare il suo codice. Ecco dove il Il prossimo() la funzione entra; Il prossimo() è usato per sbloccare l'iteratore e continuare con la funzione. Poiché la nostra funzione è dentro un infinito mentre loop, si bloccherà di nuovo per il prossimo dare la precedenza comando, e possiamo ottenere il prossimo valore con un'altra chiamata a attuale().

Il vantaggio per i generatori è che le variabili locali sono persistenti.

Se avessi avuto bisogno di fare qualcosa del genere in passato, dovresti metterlo in qualche modo per loop che precalcolizza i valori in una matrice e si ferma dopo un certo numero di iterazioni (ad esempio 100), in modo da non sovraccaricare PHP. Il vantaggio per i generatori è che le variabili locali sono persistenti e si può semplicemente scrivere ciò che la funzione dovrebbe fare, in base a come dovrebbe farlo. Ciò che intendo è che scrivi semplicemente l'attività e non preoccuparti delle variabili globali e di quante iterazioni devono essere eseguite.

L'altro modo dare la precedenza può essere usato è per ricevere dati. Funziona allo stesso modo di prima: quando la funzione raggiunge una linea con il dare la precedenza parola chiave, si fermerà, ma, invece di leggere i dati con attuale(), gli daremo i dati con inviare() funzione. Ecco un esempio di questo in azione:

 funzione Logger () $ log_num = 1; while (true) $ f = yield; echo "Log #". $ log_num ++. ":". $ F;  $ logger = Logger (); per ($ i = 0; $ i<10; $i++) $logger->send ($ i * 2); 

Questo è un semplice generatore per la visualizzazione di un messaggio di registro. Tutti i generatori iniziano in stato di pausa; una chiamata a inviare (o anche attuale) avvierà il generatore e continuerà fino a quando non colpisce a dare la precedenza comando. Il inviare il comando inserirà quindi i dati inviati e continuerà ad elaborare la funzione fino a quando non arriva al successivo dare la precedenza. Ogni successiva chiamata a inviare elaborerà un ciclo; inserirà i dati inviati in $ f, e poi continua fino a quando non torna al successivo dare la precedenza.

Quindi, perché non metterlo semplicemente in una funzione regolare? Beh, potresti, ma, allora, avresti bisogno di una variabile globale separata per tenere traccia del numero di registro, o avresti bisogno di creare una classe personalizzata.

Non pensare ai generatori come a un modo di fare qualcosa che non è mai stato possibile, ma piuttosto come uno strumento per fare le cose in modo più rapido ed efficiente.

Erano possibili anche serie infinite, ma sarebbe necessario rielaborare la lista dall'inizio ogni volta (cioè passare attraverso la matematica fino a raggiungere l'indice corrente) o memorizzare tutti i suoi dati all'interno di variabili globali. Con i generatori, il tuo codice è molto più pulito e preciso.


Elenca in per ciascuno dichiarazioni

Il prossimo aggiornamento che ho trovato abbastanza utile è la possibilità di rompere un array nidificato in una variabile locale in a per ciascuno dichiarazione. Il elenco il costrutto è in circolazione da un po '(da PHP4); esegue il mapping di un elenco di variabili a un array. Quindi, invece di scrivere qualcosa come:

 $ data = array ("John", "Smith", "032-234-4923"); $ fName = $ dati [0]; $ lName = $ data [1]; $ cell = $ data [2];

Potresti scrivere:

 $ data = array ("John", "Smith", "032-234-4923"); lista ($ fName, $ lName, $ cell) = $ dati;

L'unico problema era che, se avevi una serie di array (un array annidato) di informazioni che volevi mappare, non eri in grado di visualizzarli con un per ciascuno ciclo continuo. Invece, dovresti assegnare il per ciascuno restituire a una variabile locale e quindi mapparlo con a elenco costruire solo all'interno del ciclo.

A partire dalla versione 5.5, puoi eliminare l'intermediario e ripulire il tuo codice. Ecco un esempio del vecchio modo, contro il nuovo:

 // - Old Method - // foreach ($ parentArr as $ childArr) list ($ one, $ two) = $ childArr; // Continua con loop // - New Method - // foreach ($ parentArr come lista ($ one, $ two)) // Continua con loop

Il vecchio modo potrebbe non sembrare troppo disturbo, ma è disordinato e rende il codice meno leggibile.


API Easy Password

Sulla scheda grafica incorporata del mio Mac, sono riuscito a passare oltre 200 milioni di hash al secondo!

Ora questo richiede una piccola conoscenza di hash e crittografia per apprezzare pienamente.

Il modo più semplice per hash una password in PHP è stato usare qualcosa come l'algoritmo MD5 o SHA. Il problema con le funzioni di hash come questi sono che sono incredibilmente facili da calcolare. Non sono più utili per la sicurezza. Al giorno d'oggi, dovrebbero essere utilizzati solo per verificare l'integrità di un file. Ho installato una GPU hasher sul mio computer per testare questo reclamo. Sulla scheda grafica incorporata del mio Mac, sono riuscito a passare oltre 200 milioni di hash al secondo! Se ti fossi dedicato e investito in una configurazione multi-grafica di fascia alta, potresti potenzialmente passare miliardi di hash al secondo.

La tecnologia per questi metodi non era destinata a durare.

Quindi come risolvi questo problema? La risposta è che si pone un carico regolabile sull'algoritmo. Ciò che intendo è che rendi difficile l'elaborazione. Non che occorra un paio di secondi per hash, in quanto ciò rovinerebbe l'esperienza dell'utente. Ma immagina di averlo fatto impiegare mezzo secondo per generare. Quindi, un utente probabilmente non si accorgerebbe nemmeno del ritardo, ma qualcuno che tentasse di forzarla avrebbe dovuto percorrere milioni di tentativi - se non di più - e tutti i secondi secondi si sarebbero aggiunti a decenni e secoli. E il problema dei computer che diventano più veloci nel tempo? È qui che entra in gioco la parte "regolabile": ogni tanto aumenti la complessità per generare un hash. In questo modo, puoi assicurarti che richieda sempre lo stesso tempo. Questo è ciò che gli sviluppatori di PHP stanno cercando di incoraggiare le persone a fare.

La nuova libreria PHP è un "flusso di lavoro" di hashing, in cui le persone sono in grado di crittografare, verificare e aggiornare facilmente gli hash e le loro rispettive complessità nel tempo. Attualmente viene fornito con l'algoritmo bcrypt, ma il team di PHP ha aggiunto un'opzione, denominata default, che è possibile utilizzare. Aggiorna automaticamente gli hash all'algoritmo più sicuro, quando ne aggiungono di nuovi.

Il modo in cui bcrypt funziona è che gestisce la tua password attraverso la crittografia blowfish X quantità di volte, ma invece di usare blowfish con una chiave in modo da poterlo invertire in seguito, passa la corsa precedente come chiave alla successiva iterazione. Secondo Wikipedia, gestisce la tua password 2 al X quantità. Questa è la parte che potresti aggiustare. Dì, adesso, vuoi usare un livello di costo di 5: bcrypt eseguirà il tuo hash 2 al 5, o 32 volte. Questo può sembrare un numero basso, ma, poiché il parametro costo regola la funzione in modo esponenziale, se lo hai modificato a 15, la funzione lo eseguirà su 32768 volte. Il livello di costo predefinito è 10, ma è configurabile nel codice sorgente.

Con la teoria tolta, diamo un'occhiata a un esempio completo.

 $ pass = "Secret_Password"; $ hash = password_hash ($ pass, PASSWORD_BCRYPT, array ('cost' => 12, 'salt' => "twenty.two.letter.salt")); if (password_verify ($ pass, $ hash)) if (password_needs_rehash ($ hash, PASSWORD_DEFAULT, array ('costo' => 15))) $ hash = password_hash ($ pass, PASSWORD_DEFAULT, array ('costo' => 15));  // Fai qualcosa con hash qui. 

Il password_hash la funzione accetta tre parametri: la parola hash, una costante per l'algoritmo di hashing e un elenco opzionale di impostazioni, che includono il sale e il costo. La prossima funzione, password_verify, si assicura che una stringa corrisponda all'hash dopo la crittografia e, infine, il password_needs_rehash la funzione si assicura che un hash segua i parametri dati. Ad esempio, nel nostro caso, impostiamo il costo hash su dodici, ma, qui, ne stiamo specificando quindici, quindi la funzione restituirà vero, il che significa che deve essere ridisegnato.

Potresti aver notato che, nel password_verify e password_needs_rehash funzioni, non è necessario specificare il metodo di hashing utilizzato, il sale o il costo. Questo perché questi dettagli sono anteposti alla stringa hash.

I sali vengono utilizzati per impedire che gli hash vengano precalcolati nella tavola arcobaleno.

Il motivo per cui va bene impacchettare il costo e il sale insieme all'hash e non mantenerlo segreto, è a causa di come il sistema mette insieme i suoi punti di forza. Il costo non deve essere un segreto, perché è pensato per essere un numero che fornisce un onere abbastanza grande sul server. Ciò che intendo è che, anche se qualcuno ottiene il tuo hash e determina che il tuo livello di costo richiede 1/2 secondi per il calcolo, saprà a che livello applicare la forza bruta, ma ci vorrà troppo tempo per craccarlo (es. ).

I sali vengono utilizzati per impedire che gli hash vengano precalcolati in una tavola arcobaleno.

Una tabella arcobaleno è fondamentalmente un negozio di valori-chiave con un "dizionario" di parole con i loro hash corrispondenti come chiavi.

Tutto quello che qualcuno deve fare è precomputare abbastanza parole comuni - o, peggio, tutte le possibilità di stringa - e quindi possono cercare immediatamente la parola per un determinato hash. Ecco un esempio di come i sali possono essere d'aiuto: diciamo che la tua password è la parola "password". Normalmente, questa è una parola abbastanza comune; probabilmente sarebbe nella loro tabella arcobaleno. Quello che fa un salino è aggiungere una stringa casuale alla tua password; quindi, invece di hashing "password", è davvero un hashing "passwordRandomSalt524% # $ &." È molto meno probabile che sia pre-calcolato.

Quindi, perché i sali di solito sono considerati informazioni private? Tradizionalmente, con cose come MD5 e simili, una volta che qualcuno conosce il tuo sale, possono tornare a eseguire le loro tecniche bruteforce, tranne che aggiungeranno il tuo sale fino alla fine. Ciò significa che, invece di forzare la stringa della password casuale, sono bruteforcing di una password standard molto più breve e semplicemente aggiungendo il sale. Ma, fortunatamente, dal momento che abbiamo impostato il fattore di costo, ci vorrebbe troppo tempo per calcolare ogni hash con il nuovo sale.

Per ricapitolare: i sali assicurano che il precalcolo di un hash non possa essere riutilizzato su un altro hash e che il parametro di costo si assicuri che non sia possibile calcolare ogni hash da zero. Entrambi sono necessari, ma nessuno dei due deve essere segreto.

Questo è il motivo per cui la funzione li collega all'hash.

Ricorda, non importa quale sia il tuo sale, purché sia ​​unico.

Ora, se hai capito cosa sta facendo il sale, allora dovresti sapere che è meglio lasciare che la funzione ne generi uno a caso, piuttosto che inserire la tua stessa parola. Sebbene questa funzione sia fornita, non vuoi che tutti i tuoi hash abbiano lo stesso sale. Se lo fanno, quindi, se qualcuno è riuscito a entrare nel tuo database, tutto quello che dovrebbero fare è calcolare una volta la tabella. Dal momento che avranno il livello di sale e costi, potrebbe volerci un po ', ma, con un numero sufficiente di computer, una volta elaborati, avranno sbloccato tutti gli hash. Come tale, è molto meglio non assegnarne uno e lasciare che PHP ne generi uno a caso.


Aggiunte cURL

Fino ad ora, non c'era un modo semplice per inviare la posta tramite SMTP.

cURL è un'altra area, in cui il team di PHP ha aggiunto alcune interessanti novità e aggiornamenti. A partire dalla versione 5.5, ora abbiamo il supporto per le direttive FTP, le direttive per impostare i cookie, le direttive per SSL e gli account e le direttive per i protocolli SMTP e RTSP, tra gli altri. Ci vorrebbe troppo tempo per discuterne tutti, ma, per visualizzare l'elenco completo, è possibile fare riferimento alla pagina NEWS.

Tuttavia, voglio parlare di un set in particolare che mi interessa di più: il set di direttive SMTP. Fino ad ora, non c'era un modo semplice per inviare la posta tramite SMTP. Dovresti modificare il programma sendmail del tuo server per inviare messaggi tramite un server SMTP, oppure dovresti scaricare una libreria di terze parti, nessuna delle quali è l'opzione migliore. Con le nuove direttive CURL, puoi parlare direttamente con un server SMTP, come Gmail, in poche righe brevi.

Per capire meglio come funziona il codice, vale la pena imparare un po 'sul protocollo SMTP. Quello che succede è che il tuo script si connette al server di posta, il server di posta riconosce la tua connessione e ti restituisce le informazioni (ad es. Dominio, software). Dovrai quindi rispondere al server con il tuo indirizzo. Essendo un protocollo chiacchierone (ma educato), lo SMTP ti saluterà in modo che tu sappia che è stato ricevuto.

A questo punto, sei pronto per inviare comandi. I comandi necessari sono i POSTA DA e il RCPT TO; queste mappe si dirigono direttamente alle direttive del CURL, CURLOPT_MAIL_FROM e CURLOPT_MAIL_RCPT, rispettivamente. Ne hai solo uno a partire dal indirizzo, ma è possibile specificare più a indirizzi. Una volta fatto, puoi semplicemente chiamare il comando, DATI, e inizia a inviare le intestazioni dei messaggi e dei messaggi effettivi. Per terminare la trasmissione, devi inviare una riga vuota, seguita da un punto, seguita da un'altra riga vuota. Queste ultime due parti (vale a dire il comando DATA e la sequenza finale) sono curate da cURL, quindi non dobbiamo preoccuparcene.

Quindi, in PHP, tutto ciò che dobbiamo fare è specificare la posta a partire dal e a direttive e quindi inviare il messaggio effettivo - tutto in cURL. Per rendere le cose davvero semplici, ho intenzione di creare una classe, chiamata Gmail, che accetterà un nome utente / password e i dettagli del messaggio e invierà e-mail tramite il tuo account Gmail.

Incollo l'intera classe di seguito, e poi la esamineremo riga per riga, poiché la maggior parte di essa è standard.

 classe Gmail private $ mail; $ email privata; private $ pass; funzione pubblica __construct ($ email, $ pass) $ this-> email = $ email; $ this-> pass = $ pass;  private function mailGen () $ from = yield; $ a = rendimento; $ subject = yield; $ corpo = rendimento; rendimento "DA: <" . $from . ">\ n "; rendimento" A: <" . $to . ">\ n "; resa" Data: ". date (" r ")." \ n "; resa" Subject: ". $ subject." \ n "; resa" \ n "; resa $ body; resa" ";  public function getLine () $ risp = $ this-> mail-> current (); $ this-> mail-> next (); return $ resp; invio funzione pubblica ($ a, $ subject, $ body) $ this-> mail = $ this-> mailGen (); $ this-> mail-> invia ($ this-> email); $ this-> mail-> invia ($ a); $ this-> mail- > invia ($ oggetto); $ this-> mail-> invia ($ body); $ ch = curl_init ("smtps: //smtp.gmail.com: 465"); curl_setopt ($ ch, CURLOPT_MAIL_FROM, "<" . $this->e-mail . ">"); curl_setopt ($ ch, CURLOPT_MAIL_RCPT, array ("<" . $to . ">")); curl_setopt ($ ch, CURLOPT_USERNAME, $ this-> email); curl_setopt ($ ch, CURLOPT_PASSWORD, $ this-> pass); curl_setopt ($ ch, CURLOPT_USE_SSL, CURLUS_L_ALL); // curl_setopt ($ ch, CURLOPT_VERBOSE , true); facoltativo se si desidera visualizzare la transazione curl_setopt ($ ch, CURLOPT_READFUNCTION, array ($ this, "getLine")); return curl_exec ($ ch);

Spero che la tua reazione a questo codice sia qualcosa del tipo "Wow, questa è l'abbreviazione di un'implementazione SMTP completa!" Nel caso in cui sembri complicato, lo esamineremo. Iniziamo definendo tre variabili private: una per il generatore di messaggi, una per memorizzare l'email dell'utente e una per memorizzare la sua password. Successivamente, abbiamo il costruttore, che memorizza l'e-mail e la password per dopo; questo è così che possiamo inviare più email senza reinserire ogni volta. Il mailGen la funzione è un generatore PHP 5.5, che viene utilizzato per emettere il messaggio secondo il protocollo email direttamente in cURL. Il motivo per cui questo è necessario è perché il comando utilizzato in cURL per inserire i dati è inteso per la lettura da un file, riga per riga. Quindi, invece di avere una variabile extra per ricordare quale linea stavamo, ho usato un generatore, che salva la sua posizione.

La funzione successiva viene utilizzata per ciclare attraverso il generatore. Non possiamo entrare nel generatore direttamente in cURL; abbiamo bisogno di un intermediario cURL continuerà a chiamare questa funzione finché non arriva a una riga vuota. Questo è il motivo per cui l'ultima riga nel generatore restituisce una stringa vuota.

L'ultima funzione della classe è quella che lega tutto insieme. Inizialmente inizializziamo il generatore sulla variabile privata definita in precedenza. Successivamente, inviamo al generatore tutte le informazioni richieste e creiamo una nuova variabile cURL. Abbiamo già discusso CURLOPT_MAIL_FROM e CURLOPT_MAIL_RCPT; si associano ai comandi SMTP equivalenti. CURLOPT_MAIL_RCPT è un array in modo da poter inserire più indirizzi. Successivamente, dobbiamo aggiungere le credenziali per accedere a GMail. Ho lasciato lì l'opzione dettagliata; decommentalo, se vuoi vedere l'intera transazione SMTP. Le ultime due righe impostano semplicemente la funzione in cui CURL deve ottenere i dati per il messaggio, quindi restituiamo i risultati.

È un buon paio di linee, ma niente di eccessivamente complicato. Per utilizzare questa funzione, creare una nuova istanza di questa classe e chiamare la funzione di invio. Ecco un esempio di invio di due email con questo:

 $ gmail = new Gmail ("[email protected]", "password"); $ gmail-> invia ("[email protected]", "Oggetto dell'email", "Ciao Guy, \ n Cosa sta succedendo."); $ gmail-> invia ("[email protected]", "Oggetto diverso", "Messaggio importante.");

Bit e Bob

Per concludere questo articolo, controllerò alcuni degli aggiornamenti più piccoli a PHP 5.5.

Una cosa abbastanza interessante è il supporto aggiunto per la costante dereferenziazione di stringhe / stringhe. Ciò significa che è possibile accedere a singoli caratteri in una stringa statica, come se la stringa fosse una matrice di caratteri. Un rapido esempio di questo è il seguente:

 echo "Hello World" [1]; // questa riga echo 'e' echo ["one", "two", "three"] [2]; // questo echos "tre"

Successivamente, abbiamo il finalmente parola chiave. Questo viene aggiunto alla fine di un blocco try / catch; quello che fa è istruire PHP che, indipendentemente dal fatto che il try o il catch sia stato chiamato, si voglia processare finalmente sezione. Ciò è positivo per le situazioni, quando si desidera gestire il risultato di una dichiarazione try / catch. Invece di ripetere il codice in entrambi, puoi semplicemente inserire la parte "rischiosa" nel blocco try / catch e tutta l'elaborazione nel blocco finale.

Un altro utilizzo suggerito dal creatore come best practice consiste nel mettere tutto il codice cleanup nel blocco finally. In questo modo, ad esempio, non tenterai di chiudere lo stesso flusso più volte (ad es. Il tuo codice si è bloccato e si è inserito nel blocco catch dopo averlo chiuso e prova a chiuderlo di nuovo).

L'ultima cosa che vale la pena menzionare è come l'estensione MySQL sarà deprecata in questa nuova versione. Dovresti convertire il tuo codice in uno dei due mysqli o DOP estensioni invece. Anche se è da tempo considerato un anti-pattern, è bello che il team di PHP lo abbia ufficialmente deprecato.

Mentre ci sono sicuramente più aggiornamenti da approfondire, gli articoli in questo articolo rappresentano ciò che ritengo sia il più importante ed eccitante.


Conclusione

Grazie per aver letto; Spero che tu abbia imparato un po '! Come sempre, se avete commenti o domande, saltate nella conversazione qui sotto, e parliamo!