--- title: 'PHP 7.1 from 7.0: Nullables, void, Symmetric Destructuring & Migration | DevSense' description: "Guida all'aggiornamento di PHP 7.1: tipi nullable, tipi di ritorno void, visibilità delle costanti di classe, destrutturazione simmetrica di array, pseudo-tipo iterable, catch multiplo ed indici di stringa negativi." faq: - { question: 'Cosa sono i tipi nullable in PHP 7.1?', answer: "I tipi nullable consentono ai parametri e ai tipi di ritorno di accettare sia il tipo specificato sia null, anteponendo un punto interrogativo al nome del tipo (es. '?string')." } - { question: "Come si comporta il tipo di ritorno 'void'?", answer: "Una funzione dichiarata con un tipo di ritorno 'void' deve omettere l'istruzione return o utilizzare un 'return;' vuoto. Restituire qualsiasi valore, incluso 'null', genererà un Fatal Error." } - { question: "Cos'è la destrutturazione simmetrica degli array?", answer: "La destrutturazione simmetrica degli array consente agli sviluppatori di utilizzare la sintassi breve degli array ('[]') anziché 'list()' per disimballare gli array (es. '[$a, $b] = $arr') e supporta la specifica delle chiavi." } - { question: 'Come funziona la visibilità delle costanti di classe?', answer: "PHP 7.1 introduce la possibilità di dichiarare le costanti di classe come 'public', 'protected' o 'private', in linea con le regole di visibilità di proprietà e metodi." } published: '2026-05-31' --- # PHP 7.1: Funzionalità principali E se potessi catturare tre diversi tipi di eccezione in un unico blocco senza ripetere blocchi catch ridondanti? O definire costanti di classe che siano rigorosamente nascoste agli accessi esterni? PHP 7.1 introduce queste funzionalità, apportando una robusta sicurezza di tipizzazione e una maggiore espressività alle moderne architetture PHP. Migliora il sistema dei tipi e la sintassi con tipi nullable, funzioni void, destrutturazione simmetrica degli array con chiavi, visibilità delle costanti di classe e intercettazione di eccezioni multiple (multi-catch). ## Indice * [Tipi nullable](#nullable-types) * [Funzioni void](#void-functions) * [Destrutturazione simmetrica degli array](#symmetric-destructuring) * [Visibilità delle costanti di classe](#constant-visibility) * [Pseudo-tipo `iterable`](#iterable-type) * [Catturare più tipi di eccezione (Multi-catch)](#multi-catch) * [Chiavi nella destrutturazione list / breve](#destructuring-keys) * [Supporto per indici di stringa negativi](#negative-offsets) * [Estensioni importanti e stdlib](#extensions-stdlib) * [Ricette pratiche](#practical-recipes) * [Errori comuni](#common-mistakes) * [Limitazioni](#limitations) * [Modifiche non retrocompatibili](#backward-incompatible) * [Funzionalità deprecate (da correggere presto)](#deprecations) * [Altre modifiche](#other-changes) * [Quiz interattivo](#interactive-quiz) * [Considerazioni finali](#closing-thoughts) --- ## Tipi nullable È possibile anteporre **`?`** a qualsiasi type hint per consentire **`null`** come valore valido insieme al tipo primario: ```php // src/UserService.php function findUser(int $id): ?User { return $id === 0 ? null : new User($id); } ``` > [!NOTE] > Lo sapevi? In PHP 7.0, un type hint come `User` era assoluto: restituire `null` generava un TypeError. I tipi nullable risolvono questo problema senza costringere gli sviluppatori ad abbandonare del tutto il type hinting. --- ## Funzioni void Le funzioni che non restituiscono nulla utilizzano **`void`**. È consentito solo un **`return;`** vuoto o l'omissione completa del return. La restituzione di qualsiasi altra cosa (inclusa la restituzione esplicita di **`return null;`**) costituisce un errore in fase di compilazione. ```php // src/Notifier.php function notify(string $message): void { echo $message; return; // Un return vuoto è valido, la restituzione di qualsiasi valore è un errore di tipo } ``` > [!NOTE] > Lo sapevi? `void` è un tipo di solo ritorno. Non è possibile utilizzarlo per definire il tipo di un parametro di funzione (es. `function foo(void $x)` non è valido). --- ## Destrutturazione simmetrica degli array Consente di disimballare gli array utilizzando la sintassi breve degli array **`[]`** in alternativa a **`list()`**: ```php // src/Config.php [$host, $port] = ['127.0.0.1', 3306]; ``` Questa sintassi può essere utilizzata anche nei cicli `foreach`: `foreach ($data as [$id, $name])`. --- ## Visibilità delle costanti di classe Le costanti possono avere visibilità **`public`**, **`protected`** o **`private`**: ```php // src/PaymentGateway.php class PaymentGateway { private const API_KEY = 'secret-key'; public const DEFAULT_TIMEOUT = 30; } ``` > [!NOTE] > Lo sapevi? Le costanti sono impostate come `public` per impostazione predefinita se non viene dichiarato alcun modificatore di visibilità, mantenendo la retrocompatibilità con le versioni precedenti di PHP. --- ## Pseudo-tipo `iterable` Corrisponde a qualsiasi valore che soddisfi **`is_array()`** o sia un'istanza di **`\Traversable`**: ```php // src/Collection.php function processItems(iterable $items): void { foreach ($items as $item) { // Funziona sia per gli array sia per gli oggetti generatore/iteratore } } ``` --- ## Catturare più tipi di eccezione (Multi-catch) Cattura eccezioni diverse in un unico blocco utilizzando l'operatore **`|`**: ```php // src/ApiConnector.php try { // Esegui la richiesta API } catch (ConnectionException | ResponseException $e) { // Gestisci entrambi i tipi di eccezione qui } ``` --- ## Chiavi nella destrutturazione list / breve È possibile specificare le chiavi quando si effettua la destrutturazione degli array: ```php // src/UserProfile.php ['id' => $userId, 'name' => $username] = $user; ``` Questo funziona sia per `list()` sia per la nuova sintassi breve `[]`. --- ## Supporto per indici di stringa negativi Indicizza le stringhe partendo dalla fine utilizzando numeri negativi: ```php // src/StrHelper.php $lastChar = 'abcdef'[-1]; // 'f' $sub = substr('abcdef', -3, -1); // 'de' ``` Gli indici negativi sono supportati anche per l'accesso ai caratteri di una stringa: `$str[-2] = 'z';`. --- ## Estensioni importanti e stdlib * **cURL HTTP/2**: Supporto per HTTP/2 push e funzionalità multi-server. * **OpenSSL AEAD**: Aggiunto supporto per le modalità AEAD (GCM e CCM). * **`session_gc()`**: Espone esplicitamente il garbage collector delle sessioni standard. --- ## Ricette pratiche ### Firma del metodo nullable ```php // src/recipes.php public function setName(?string $name): void { $this->name = $name; } ``` ### Disimballare le righe del database con le chiavi ```php // src/recipes.php foreach ($rows as ['id' => $id, 'role' => $role]) { // ... } ``` --- ## ⚠️ Errori comuni Ecco i tipici tranelli in PHP 7.1: ### 1. Restituire `null` da una funzione `void` In PHP 7.1, la restituzione esplicita di `null` da una funzione contrassegnata come `void` genera un errore fatale. ```php // src/BadVoid.php // Errato: la restituzione esplicita di null è vietata per i tipi di ritorno void function doNothing(): void { return null; // Fatal Error: A void function must not return a value } ``` ```php // src/GoodVoid.php // Corretto: usa un return vuoto o omettilo del tutto function doNothingGood(): void { return; } ``` ### 2. Presumere che `iterable` accetti solo array Il controllo `is_array()` su un parametro `iterable` potrebbe escludere generatori o classi iteratore, causando errori di runtime imprevisti. ```php // src/BadIterable.php // Errato: genera errori se $items è un oggetto Traversable e non un array function dumpItems(iterable $items) { echo count($items); // Fatal Error se $items è un generatore (non Countable) } ``` ```php // src/GoodIterable.php // Corretto: converti in array se necessario o usa foreach (che gestisce entrambi) function dumpItemsGood(iterable $items) { foreach ($items as $item) { echo $item; } } ``` --- ## Limitazioni * **Tipi nullable**: Non è possibile combinare tipi nullable con i tipi Union. Scrivere `?int|string` costituisce un errore di sintassi (i tipi Union sono stati introdotti in PHP 8.0). * **Visibilità delle costanti**: Impone il controllo degli accessi ma non supporta la tipizzazione delle costanti di classe. Scrivere `public const int TIMEOUT = 10;` rimane un errore di sintassi fino a PHP 8.3. --- ## Modifiche non retrocompatibili ### Core e tipi * **Errore in caso di argomenti insufficienti**: il passaggio di un numero insufficiente di argomenti a una funzione definita dall'utente ora genera un'eccezione **`ArgumentCountError`** (anziché un Warning). * **Comportamento degli indici di stringa**: l'accesso con indici vuoti `[]` sulle stringhe **non è più silenzioso** né tollerato. * **`iterable` è una parola riservata**: non è consentito assegnare il nome `iterable` a una classe, interfaccia o trait. --- ## Quiz interattivo Metti alla prova la tua conoscenza di PHP 7.1: 1. **Quale delle seguenti affermazioni è vera per una funzione con tipo di ritorno `void`?** * A) Deve restituire esplicitamente `null`. * B) Non può contenere alcuna istruzione `return`. * C) Può utilizzare un `return;` vuoto o ometterlo. * D) Restituisce `false` per impostazione predefinita.
Clicca per vedere la risposta **Risposta corretta: C** Una funzione `void` può utilizzare un'istruzione `return;` vuota per uscire anticipatamente o ometterla del tutto, ma la restituzione di qualsiasi valore (anche `null`) è un errore di sintassi.
2. **Quale eccezione viene generata quando vengono passati troppo pochi argomenti a una funzione utente in PHP 7.1?** * A) TypeError * B) ArgumentCountError * C) WarningException * D) Error
Clicca per vedere la risposta **Risposta corretta: B** PHP 7.1 eleva gli avvisi relativi agli argomenti mancanti a un'eccezione lanciabile `ArgumentCountError`.
3. **Come si definisce una costante di classe accessibile solo all'interno della classe stessa?** * A) `private const MY_CONST = 1;` * B) `const private MY_CONST = 1;` * C) `protected const MY_CONST = 1;` * D) `private MY_CONST = 1;`
Clicca per vedere la risposta **Risposta corretta: A** PHP 7.1 consente alle costanti di classe di utilizzare i modificatori di visibilità standard: `public const`, `protected const` o `private const`.
--- ## Considerazioni finali PHP 7.1 è una release fondamentale per la **corretta gestione della tipizzazione rigorosa** e per strutture dati più pulite. Converti le vecchie strutture `list()` in `[]`, aggiungi `?` agli argomenti facoltativi e adegua i tuoi blocchi catch per le eccezioni per preparare la tua applicazione a PHP 7.2+.