{"id":47870,"date":"2021-09-24T15:09:11","date_gmt":"2021-09-24T13:09:11","guid":{"rendered":"https:\/\/kinsta.com\/?p=100177"},"modified":"2023-03-14T14:35:01","modified_gmt":"2023-03-14T13:35:01","slug":"traspiling-php","status":"publish","type":"post","link":"https:\/\/kinsta.com\/it\/blog\/traspiling-php\/","title":{"rendered":"Guida Definitiva al Transpiling del Codice PHP"},"content":{"rendered":"

In circostanze ideali, dovremmo usare PHP 8.0<\/a> (l’ultima versione al momento in cui scriviamo questo articolo) per tutti i nostri siti e aggiornarlo non appena viene rilasciata una nuova versione. Tuttavia, gli sviluppatori avranno spesso bisogno di lavorare con precedenti versioni di PHP, come quando si crea un plugin pubblico per WordPress<\/a> o si lavora con codice legacy che impedisce di aggiornare l’ambiente del webserver.<\/p>\n

In queste situazioni, potremmo abbandonare la speranza di utilizzare il pi\u00f9 recente codice PHP. Ma c’\u00e8 un’alternativa migliore: possiamo ancora scrivere il nostro codice sorgente con PHP 8.0 e tradurlo in una versione precedente di PHP – anche in PHP 7.1.<\/p>\n

In questa guida spiegheremo tutto quello che c’\u00e8 da sapere sul transpiling del codice PHP.<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Cos’\u00e8 il Transpiling?<\/h2>\n

Il transpiling converte il codice sorgente di un linguaggio di programmazione<\/a> in un codice sorgente equivalente dello stesso o di un diverso linguaggio di programmazione.<\/p>\n

La compilazione non \u00e8 un concetto nuovo nello sviluppo web: gli sviluppatori lato client avranno probabilmente familiarit\u00e0 con Babel<\/a>, un transpiler per il codice JavaScript.<\/p>\n

Babel converte il codice JavaScript dalla moderna versione ECMAScript 2015+ in una versione legacy compatibile con i vecchi browser. Ad esempio, data una arrow function ES2015:<\/p>\n

[2, 4, 6].map((n) => n * 2);\n<\/code><\/pre>\n
…Babel la convertir\u00e0 nella sua versione ES5:<\/p>\n
[2, 4, 6].map(function(n) {\n  return n * 2;\n});<\/code><\/pre>\n
Che cos’\u00e8 il Transpiling di PHP?<\/h3>\n
Ci\u00f2 che forse \u00e8 nuovo nello sviluppo web \u00e8 la possibilit\u00e0 di effettuare il transpiling del codice lato server, in particolare di PHP.<\/p>\n
Il transpiling di PHP funziona allo stesso modo del transpiling di JavaScript: il codice sorgente di una versione moderna di PHP<\/a> viene convertito in un codice equivalente per una vecchia versione di PHP.<\/p>\n
Seguendo lo stesso esempio di prima, una arrow function da PHP 7.4:<\/p>\n
$nums = array_map(fn($n) => $n * 2, [2, 4, 6]);\n<\/code><\/pre>\n
…pu\u00f2 essere trasformata nella sua versione equivalente in PHP 7.3:<\/p>\n
$nums = array_map(\n  function ($n) {\n    return $n * 2;\n  },\n  [2, 4, 6]\n);<\/code><\/pre>\n
Le arrow function possono essere oggetto di traspiling perch\u00e9 sono syntactic sugar<\/a>, cio\u00e8 una nuova sintassi per produrre un comportamento esistente. Questo \u00e8 il beneficio maggiore.<\/p>\n
Ma ci sono anche nuove funzioni che creano un nuovo comportamento e, come tali, non ci sar\u00e0 un codice equivalente per le versioni precedenti di PHP. \u00c8 il caso dei tipi unione<\/a>, introdotti in PHP 8.0:<\/p>\n
function someFunction(float|int $param): string|float|int|null\n{\n  \/\/ ...\n}<\/code><\/pre>\n
In queste situazioni, il transpiling pu\u00f2 comunque essere eseguito finch\u00e9 la nuova funzionalit\u00e0 \u00e8 richiesta per lo sviluppo e non per la produzione. Poi, possiamo semplicemente rimuovere del tutto la funzionalit\u00e0 dal codice oggetto di transpiling senza gravi conseguenze.<\/p>\n
Uno di questi esempi sono i tipi unione. Questa funzionalit\u00e0 permette di controllare che non ci sia una mancata corrispondenza tra il tipo di input e il suo valore fornito, il che aiuta a prevenire i bug. Se c’\u00e8 un conflitto con i tipi, ci sar\u00e0 un errore gi\u00e0 nello sviluppo e dovremmo correggerlo prima che il codice raggiunga la produzione.<\/p>\n
Quindi, possiamo permetterci di rimuovere la funzionalit\u00e0 dal codice per la produzione:<\/p>\n
function someFunction($param)\n{\n  \/\/ ...\n}<\/code><\/pre>\n
Se l’errore si verifica ancora in produzione, il messaggio di errore lanciato sar\u00e0 meno preciso che se avessimo i tipi unione. Tuttavia, questo possibile svantaggio \u00e8 superato in primo luogo dall’essere in grado di utilizzare i tipi unione.<\/p>\n\n
Vantaggi del Transpiling del Codice PHP<\/h2>\n
Il transpiling permette di creare il codice di un’applicazione utilizzando l’ultima versione di PHP e produrre una versione che funziona anche in ambienti che eseguono vecchie versioni di PHP.<\/p>\n
Questo pu\u00f2 essere particolarmente utile per gli sviluppatori che creano prodotti per sistemi di gestione dei contenuti (CMS)<\/a> legacy. WordPress, per esempio, supporta<\/a> ancora ufficialmente PHP 5.6<\/a> (anche se raccomanda PHP 7.4+). La percentuale di siti WordPress che eseguono le versioni PHP da 5.6 a 7.2 – che sono tutte End-of-Life (EOL), il che significa che non ricevono pi\u00f9 aggiornamenti di sicurezza – si attesta su un considerevole 34,8%, e quelli che eseguono qualsiasi versione di PHP diversa dalla 8.0 si attesta su un enorme 99,5%:<\/p>\n
\"Statistiche<\/a>
Statistiche sull’utilizzo di WordPress per versione. Fonte immagine: WordPress<\/a><\/figcaption><\/figure>\n
Di conseguenza, i temi e i plugin di WordPress destinati ad un pubblico globale saranno molto probabilmente codificati con una vecchia versione di PHP per aumentarne la portata. Grazie al transpiling, questi potrebbero essere codificati utilizzando PHP 8.0, ed essere comunque rilasciati per una vecchia versione di PHP, raggiungendo cos\u00ec il maggior numero di utenti possibile.<\/p>\n
Infatti, qualsiasi applicazione che ha bisogno di supportare una qualsiasi versione di PHP diversa da quella pi\u00f9 recente (anche all’interno della gamma delle versioni PHP attualmente supportate) pu\u00f2 beneficiarne.<\/p>\n
Questo \u00e8 il caso di Drupal, che richiede PHP 7.3<\/a>. Grazie al transpiling, gli sviluppatori possono creare moduli Drupal disponibili al pubblico utilizzando PHP 8.0 e rilasciarli con PHP 7.3.<\/p>\n
Un altro esempio \u00e8 quando si crea codice personalizzato per clienti che non possono eseguire PHP 8.0 nei loro ambienti per una ragione o per l’altra. Tuttavia, grazie al transpiling, gli sviluppatori possono sviluppare i propri prodotti usando PHP 8.0 ed eseguirli su quegli ambienti legacy.<\/p>\n
Quando Effettuare il Transpiling di PHP<\/h3>\n
Il codice PHP pu\u00f2 sempre essere oggetto di transpiling, a meno che non contenga qualche funzionalit\u00e0 di PHP che non ha un equivalente nella versione precedente di PHP.<\/p>\n
Questo \u00e8 probabilmente il caso degli attributi<\/a>, introdotti in PHP 8.0:<\/p>\n
#[SomeAttr]\nfunction someFunc() {}\n\n#[AnotherAttr]\nclass SomeClass {}<\/code><\/pre>\n
Nell’esempio precedente in cui si utilizzavano le arrow function, era possibile eseguire il transpiling perch\u00e9 le arrow function sono sintactic sugar. Gli attributi, al contrario, creano un comportamento completamente nuovo. Questo comportamento potrebbe anche essere riprodotto con PHP 7.4 e successivi, ma solo codificando manualmente, cio\u00e8 non automaticamente sulla base di uno strumento o di un processo (l’AI potrebbe fornire una soluzione, ma non ci siamo ancora).<\/p>\n
Gli attributi destinati allo sviluppo, come #[Deprecated]<\/code><\/a>possono essere rimossi nello stesso modo in cui vengono rimossi i tipi unione. Ma gli attributi che modificano il comportamento dell’applicazione in produzione non possono essere rimossi e non possono nemmeno essere direttamente oggetto di transpiling.<\/p>\n
Ad oggi, nessun transpiler pu\u00f2 prendere del codice con attributi PHP 8.0 e produrre automaticamente il loro equivalente in PHP 7.4. Di conseguenza, se il vostro codice PHP ha bisogno di utilizzare gli attributi, allora il transpiling sar\u00e0 difficile o irrealizzabile.<\/p>\n
Funzionalit\u00e0 di PHP che Possono Essere Oggetto di Transpiling<\/h3>\n
Queste sono le funzionalit\u00e0 di PHP 7.1 e superiori che possono essere attualmente oggetto di transpiling. Se il vostro codice utilizza solo queste funzionalit\u00e0, potete star certi che il transpiling della vostra applicazione funzioner\u00e0. Altrimenti, dovrete valutare se il codice codice oggetto di transpiling produce dei failure.<\/p>\n\n\n\n\n\n\n\n\n\n
Versione PHP<\/th>\nFunzionalit\u00e0<\/th>\n<\/tr>\n<\/thead>\n
7.1<\/td>\nTutto<\/td>\n<\/tr>\n
7.2<\/td>\n– tipo object<\/a>
\n– ampliamento del tipo di parametro<\/a>
\n– Flag PREG_UNMATCHED_AS_NULL<\/code> in preg_match<\/code><\/a><\/td>\n<\/tr>\n
7.3<\/td>\n– Assegnazioni di riferimento nella destrutturazione di list()<\/code><\/a> \/ array(eccetto all’interno di foreach<\/code> – #4376<\/a><\/em>)
\n– Sintassi Heredoc e Nowdoc flessibile<\/a>
\n– Virgole finali nelle chiamate di funzioni<\/a>
\n– set(raw)cookie<\/code> accetta l’argomento $option<\/a><\/td>\n<\/tr>\n
7.4<\/td>\n– Propriet\u00e0 tipizzate<\/a>
\n– Arrow function<\/a>
\n– Operatore di assegnazione Null coalescente<\/a>
\n– Spacchettamento all’interno degli array<\/a>
\n– Separatore di letterali numerici<\/a>
\n– strip_tags()<\/code><\/a> con array di nomi di tag
\n– tipi di ritorno covarianti e tipi di param controvarianti<\/a><\/td>\n<\/tr>\n
8.0<\/td>\n– Tipi unione<\/a>
\n– pseudo tipo mixed<\/code><\/a>
\n– tipo di ritorno static<\/code><\/a>
\n– ::class<\/code><\/a> costante magica sugli oggetti
\n– match<\/code><\/a> alle espressioni
\n– catch<\/code><\/a> le eccezioni solo per tipo
\n– Operatore null-safe<\/a>
\n– Promozione delle propriet\u00e0 del costruttore di classe<\/a>
\n– Virgole finali negli elenchi di parametri e negli elenchi di chiusure use<\/code><\/a><\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Transpiler PHP<\/h2>\n
Attualmente, c’\u00e8 uno strumento per il transpiling del codice PHP: Rector<\/a>.<\/p>\n
Rector \u00e8 uno strumento di ricostruzione di PHP, che converte il codice basandosi su regole programmabili. Inseriamo il codice sorgente e l’insieme di regole<\/a> da eseguire e Rector trasformer\u00e0 il codice.<\/p>\n
Rector viene utilizzato tramite linea di comando, installato nel progetto tramite Composer. Quando viene eseguito, Rector produce un “diff” (aggiunte in verde, rimozioni in rosso) del codice prima e dopo la conversione:<\/p>\n
<\/a>
Uscita “diff” da Rector<\/figcaption><\/figure>\n
A Quale Versione di PHP Eseguire il Transpiling<\/h2>\n
Per effettuare il transpiling del codice alle varie versioni di PHP, devono essere create le regole corrispondenti.<\/p>\n
Oggi, la libreria Rector include la maggior parte delle regole per trasportare il codice all’interno della gamma che va da PHP 8.0 a 7.1. Quindi possiamo effettuare il transpiling del nostro codice PHP in modo affidabile fino alla versione 7.1.<\/p>\n
Ci sono anche regole per la compilazione da PHP 7.1 a 7.0<\/a> e da 7.0 a 5.6<\/a>, ma queste non sono esaustive. Si sta lavorando per completarle, cos\u00ec alla fine potremo effettuare il transpiling del codice PHP fino alla versione 5.6.<\/p>\n
Transpiling e Backporting<\/h2>\n
Il backporting \u00e8 simile al transpiling, ma pi\u00f9 semplice. Il codice di backporting non si basa necessariamente su nuove funzionalit\u00e0 di un linguaggio, perch\u00e9 la stessa funzionalit\u00e0 pu\u00f2 essere fornita ad una vecchia versione del linguaggio semplicemente copiando\/incollando\/adattando il codice corrispondente dalla nuova versione del linguaggio.<\/p>\n
Ad esempio, la funzione str_contains<\/code> \u00e8 stata introdotta in PHP 8.0. La stessa funzione per PHP 7.4 e successivi pu\u00f2 essere facilmente implementata in questo modo:<\/p>\n
if (!defined('PHP_VERSION_ID') || (defined('PHP_VERSION_ID') && PHP_VERSION_ID < 80000)) {\n  if (!function_exists('str_contains')) {\n    \/**\n     * Checks if a string contains another\n     *\n     * @param string $haystack The string to search in\n     * @param string $needle The string to search\n     * @return boolean Returns TRUE if the needle was found in haystack, FALSE otherwise.\n     *\/\n    function str_contains(string $haystack, string $needle): bool\n    {\n      return strpos($haystack, $needle) !== false;\n    }\n  }\n}<\/code><\/pre>\n
Dato che il backporting \u00e8 pi\u00f9 semplice del transpiling, dovremmo optare per questa soluzione ogni volta che il backporting pu\u00f2 fare il lavoro.<\/p>\n
Per quanto riguarda il range tra PHP 8.0 e 7.1, possiamo utilizzare le librerie polyfill di Symfony<\/a>:<\/p>\n