--- title: 'PHP 5.6: Variadics, Argument Unpacking, ** & Migration | DevSense' description: "Guida all'aggiornamento di PHP 5.6: scopri i parametri variadici, il disimballaggio degli argomenti con ..., l'operatore di elevamento a potenza **, gli import di funzioni/costanti, le espressioni costanti, hash_equals e i requisiti SSL/TLS più severi." faq: - { question: 'Cosa sono i parametri Variadici in PHP 5.6?', answer: "I parametri variadici consentono di specificare che una funzione accetta un numero variabile di argomenti utilizzando l'operatore `...` nella firma dei parametri (es. `function sum(...$numbers)`)." } - { question: 'Come funziona il disimballaggio degli argomenti (argument unpacking) in PHP 5.6?', answer: "Il disimballaggio degli argomenti consente di passare un array o un oggetto Traversable a una chiamata di funzione come argomenti separati, anteponendo alla variabile l'operatore `...` (es. `format(...$args)`)." } - { question: "Qual è la differenza tra pow() e l'operatore **?", answer: "L'operatore `**` è associativo a destra (quindi `2 ** 3 ** 2` viene valutato come `2 ** (3 ** 2)`), mentre `pow()` è una chiamata a funzione standard. L'operatore `**` ha anche una precedenza maggiore rispetto agli operatori unari." } - { question: 'Perché hash_equals() è importante in PHP 5.6?', answer: 'Fornisce un metodo di confronto tra stringhe sicuro contro i timing attack per token e firme crittografiche, impedendo agli aggressori di indovinare i token in base al tempo impiegato per il confronto.' } published: '2026-05-31' --- # PHP 5.6: Il ponte verso il PHP moderno Una semplice espressione matematica come `2 ** 3 ** 2` o un controllo di convalida rigoroso su un input JSON fornito dall'utente possono alterare completamente la logica di esecuzione del programma quando si passa a PHP 5.6. Essendo l'ultima versione del ramo 5.x, PHP 5.6 rappresenta il ponte tra il vecchio motore PHP e il moderno runtime PHP 7. Prima di PHP 5.6, la scrittura di funzioni con un numero dinamico di argomenti richiedeva l'uso di funzioni obsolete come `func_get_args()` e il loro inoltro tramite chiamate lente a `call_user_func_array()`. L'importazione di funzioni da namespace richiedeva wrapper complessi e i valori delle costanti non potevano contenere formule matematiche di base. > [!IMPORTANT] > PHP 5.6 ha introdotto le firme variadiche, il disimballaggio degli argomenti e valori di crittografia predefiniti più severi per preparare le basi di codice al grande salto verso PHP 7. --- ## Indice * [Parametri Variadici (`...$params`)](#variadic) * [Disimballaggio degli argomenti (Argument Unpacking)](#unpacking) * [Operatore di elevamento a potenza (`**`)](#pow-op) * [`use function` e `use const`](#use-imports) * [Espressioni costanti](#const-expr) * [Confronto tra stringhe sicuro rispetto al tempo (`hash_equals`)](#hash-equals) * [Errori comuni](#common-mistakes) * [Ricette pratiche](#practical-recipes) * [Modifiche non retrocompatibili](#backward-incompatible) * [🧠 Domande di autovalutazione](#self-check) --- ## Parametri Variadici (`...$params`) Le funzioni possono ora accettare nativamente un numero variabile di argomenti senza affidarsi a `func_get_args()`. ```php // app/Helpers/Math.php function sum(int $first, int ...$others): int { $accumulator = $first; foreach ($others as $number) { $accumulator += $number; } return $accumulator; } echo sum(1, 2, 3, 4); // 10 ``` * **Perché è importante**: Le definizioni delle firme ora sono autodocumentate e gli IDE possono verificare correttamente i tipi e completare automaticamente gli argomenti variadici. --- ## Disimballaggio degli argomenti (Argument Unpacking) Gli array e gli oggetti `Traversable` possono essere disimballati nell'elenco dei parametri durante le chiamate di funzione. ```php // app/Services/Logger.php $args = ["User %s logged in from IP %s", "admin", "127.0.0.1"]; echo sprintf(...$args); ``` * **Perché è importante**: Sostituisce le chiamate a `call_user_func_array()`, lente e difficili da leggere, con una velocità nativa a livello di compilatore. --- ## Operatore di elevamento a potenza (`**`) PHP 5.6 introduce l'operatore `**` per calcolare le potenze, fornendo una scorciatoia per la funzione `pow()`. ```php // app/Services/Physics.php $square = 4 ** 2; // 16 $cube = 2 ** 3; // 8 ``` > [!WARNING] > L'operatore `**` è associativo a destra. Ciò significa che `2 ** 3 ** 2` viene valutato come `2 ** (3 ** 2) = 2 ** 9 = 512`, non come `(2 ** 3) ** 2 = 8 ** 2 = 64`. --- ## `use function` e `use const` Il blocco namespace `use` è esteso per supportare l'importazione di funzioni e costanti, non solo di classi. ```php // app/Services/StringManager.php namespace App\Services; use function SomeLib\stringHelper; use const SomeLib\API_VERSION; class StringManager { public function getVersion(): string { return stringHelper(API_VERSION); } } ``` * **Perché è importante**: Mantiene puliti i namespace globali e dichiara esplicitamente le dipendenze delle librerie esterne all'inizio del file. --- ## Espressioni costanti È ora possibile utilizzare espressioni scalari (formule matematiche, concatenazione di stringhe) quando si definiscono costanti di classe, valori predefiniti di proprietà statiche e valori predefiniti dei parametri. ```php // app/Config/Limits.php class Limits { public const ONE_MB = 1024 * 1024; public const MAX_UPLOAD = self::ONE_MB * 50; // 50MB public static $debugMode = (self::MAX_UPLOAD > 10000); } ``` --- ## Confronto tra stringhe sicuro rispetto al tempo (`hash_equals`) Confronta due stringhe in tempo costante, indipendentemente dal fatto che i caratteri corrispondano o meno. ```php // app/Services/Security.php $signature = $_GET['signature']; $expected = hash_hmac('sha256', $data, $key); if (hash_equals($expected, $signature)) { // Verificato con successo } ``` * **Perché è importante**: Previene gli attacchi temporali (timing attack) a canale laterale durante la convalida di token utente, password o firme HMAC. --- ## ⚠️ Errori comuni ### 1. Operatori unari e precedenza dell'elevamento a potenza La combinazione di `-` o altri operatori unari con `**` senza parentesi può produrre calcoli matematici imprevisti. ```php // app/Demo/MathErrors.php // ❌ Errore di compilazione! L'elevamento a potenza ha una precedenza maggiore $result = -2 ** 2; // ✅ Approccio corretto $result = (-2) ** 2; // 4 ``` ### 2. Affidarsi a `$HTTP_RAW_POST_DATA` Prima di PHP 5.6, `$HTTP_RAW_POST_DATA` veniva popolato per payload POST non multipart. È deprecato in PHP 5.6. ```php // app/Http/Webhook.php // ❌ Deprecato in PHP 5.6, genera un avviso E_DEPRECATED $data = $HTTP_RAW_POST_DATA; // ✅ Approccio corretto $data = file_get_contents('php://input'); ``` ### 3. Gestione superficiale dei fallimenti di `json_decode()` `json_decode()` ora rifiuta rigorosamente i valori letterali JSON non validi (`true`/`false`/`null` forniti come stringhe malformate), sollevando errori nei casi in cui prima rimaneva silenzioso. --- ## Ricette pratiche ### Aggiornamento di `call_user_func_array` ```php // app/Demo/UnpackDemo.php class Invoker { public function execute(callable $callback, array $params) { // Aspettativa: Sostituzione del lento call_user_func_array con il disimballaggio // Realtà: // PHP 5.5: call_user_func_array($callback, $params); // PHP 5.6: return $callback(...$params); } } ``` --- ## Modifiche non retrocompatibili 1. **Requisiti SSL/TLS severi per impostazione predefinita**: La verifica dei peer è abilitata per impostazione predefinita. Gli stream sicuri che si connettono a host con certificati autofirmati falliranno a meno che non vengano configurati con contesti di stream personalizzati. 2. **Precedenza di `**`**: La precedenza associativa a destra può alterare i calcoli importati da motori PHP precedenti. 3. **Rigore di `json_decode()`**: I valori letterali JSON non minuscoli come `TRUE`, `FALSE` o `NULL` genereranno errori di sintassi. 4. **Sovrascrittura delle chiavi degli array**: Le dichiarazioni statiche di array che contengono chiavi duplicate sovrascriveranno le chiavi nell'ordine in cui sono definite. --- ## 🧠 Domande di autovalutazione 1. **Vero o Falso?** L'operatore `...` può essere utilizzato più volte nella firma dei parametri della stessa funzione. 2. Qual è il risultato della valutazione di `2 ** 3 ** 2` in PHP 5.6? 3. Quale meccanismo sostituisce `$HTTP_RAW_POST_DATA`? 4. **Vero o Falso?** `hash_equals()` è sicuro contro i timing attack perché confronta le stringhe in tempo variabile.
Mostra risposte 1. **Falso.** Una funzione può avere un solo parametro variadico, e deve essere l'ultimo parametro della firma. 2. `512` (perché è associativo a destra: `3 ** 2 = 9`, quindi `2 ** 9 = 512`). 3. La lettura degli input grezzi da `php://input`. 4. **Falso.** È sicuro perché confronta le stringhe in tempo **costante**, il che significa che il tempo di esecuzione non cambia in base al numero di caratteri corretti.