---
title: 'PHP 7.0 from 5.6: Zend Engine 3, Scalar Types, ??, <=> & Migration | DevSense'
description: "Guida all'aggiornamento di PHP 7.0: dichiarazioni di tipo scalare, tipi di ritorno, null coalescing (??), operatore spaceship (<=>), classi anonime, Throwable, CSPRNG e modifiche non retrocompatibili."
faq:
    - { question: 'Cosa sono le dichiarazioni di tipo scalare in PHP 7.0?', answer: "PHP 7.0 consente agli sviluppatori di imporre tipi (int, float, string, bool) per i parametri delle funzioni. Dichiarando 'declare(strict_types=1);' all'inizio di un file, la conversione automatica dei tipi viene disabilitata." }
    - { question: "Come funziona l'operatore di null coalescing (??)?", answer: "L'operatore di null coalescing ('??') restituisce il suo primo operando se esiste e non è nullo; in caso contrario, restituisce il secondo operando. È una scorciatoia per i comuni controlli 'isset()'." }
    - { question: "A cosa serve l'operatore spaceship (<=>)?", answer: "L'operatore spaceship ('<=>') confronta due espressioni. Restituisce -1 se il termine a sinistra è minore di quello a destra, 0 se sono uguali e 1 se quello a sinistra è maggiore, rendendo le funzioni di ordinamento estremamente leggibili." }
    - { question: 'Qual è la differenza tra Exception e Throwable in PHP 7.0?', answer: "PHP 7.0 introduce l'interfaccia 'Throwable'. Sia 'Exception' che la nuova classe 'Error' (che rappresenta gli errori del motore) implementano 'Throwable'. È necessario catturare 'Throwable' per gestire entrambe le classi." }
published: '2026-05-31'
---
# PHP 7.0: Funzionalità principali

E se potessi raddoppiare le prestazioni della tua applicazione da un giorno all'altro semplicemente aggiornando il motore del linguaggio? PHP 7.0 ha ottenuto esattamente questo risultato. Spinto dal nuovo Zend Engine 3, ha introdotto enormi miglioramenti di velocità, introducendo al contempo dichiarazioni di tipi scalari rigorosi, tipi di ritorno e operatori moderni come il null coalescing. PHP 7.0 segna un salto monumentale nella storia di PHP, ponendo le basi per le moderne applicazioni web ad alte prestazioni e tipizzazione sicura.

## Indice
* [Dichiarazioni di tipo scalare](#scalar-types)
* [Dichiarazioni del tipo di ritorno](#return-types)
* [Operatore null coalescing (`??`)](#null-coalescing)
* [Operatore spaceship (`<=>`)](#spaceship-operator)
* [Array di costanti tramite `define()`](#constant-arrays)
* [Classi anonime](#anonymous-classes)
* [Sintassi di escape per i codepoint Unicode](#unicode-escape)
* [Dichiarazioni use di gruppo](#group-use)
* [Interfaccia Throwable ed eccezioni del motore](#throwable-exceptions)
* [Funzioni CSPRNG](#csprng-functions)
* [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)

---

<a id="scalar-types"></a>
## Dichiarazioni di tipo scalare

I parametri scalari possono utilizzare i type hint: **`int`**, **`float`**, **`string`** e **`bool`**:

```php
// src/Math.php
declare(strict_types=1);

function add(int $a, int $b): int 
{
    return $a + $b;
}
```

> [!NOTE]
> Lo sapevi? Senza `declare(strict_types=1);` all'inizio del file, PHP rimane in **modalità coercitiva**, il che significa che convertirà silenziosamente stringhe come `"5"` in numeri interi per soddisfare i controlli dei parametri.

---

<a id="return-types"></a>
## Dichiarazioni del tipo di ritorno

Definiscono il tipo che una funzione è tenuta a restituire:

```php
// src/Generator.php
function generateId(): string 
{
    return uniqid();
}
```

Se un'istruzione di ritorno non corrisponde a questo tipo, PHP genererà un'eccezione **`TypeError`**.

---

<a id="null-coalescing"></a>
## Operatore null coalescing (`??`)

Zucchero sintattico per i controlli `isset()`:

```php
// src/Config.php
$username = $_GET['user'] ?? 'anonymous';
```

Può essere concatenato: `$value = $a ?? $b ?? $default;`.

---

<a id="spaceship-operator"></a>
## Operatore spaceship (`<=>`)

Confronto a tre vie che restituisce `-1`, `0` o `1`:

```php
// src/SortHelper.php
usort($list, function($a, $b) {
    return $a <=> $b;
});
```

Utile per le operazioni di ordinamento in cui i confronti standard richiederebbero una logica condizionale prolissa.

---

<a id="constant-arrays"></a>
## Array di costanti tramite `define()`

Definisce costanti array a runtime:

```php
// src/Constants.php
define('ALLOWED_ROLES', ['admin', 'editor', 'guest']);
```

In precedenza, gli array potevano essere definiti come costanti solo all'interno delle classi utilizzando `const`.

---

<a id="anonymous-classes"></a>
## Classi anonime

Istanziano oggetti semplici e monouso:

```php
// src/LoggerProvider.php
$logger = new class {
    public function log(string $msg) {
        echo $msg;
    }
};
```

Utile per simulare (mock) interfacce durante gli unit test.

---

<a id="unicode-escape"></a>
## Sintassi di escape per i codepoint Unicode

Consente di inserire simboli Unicode direttamente nelle stringhe:

```php
// src/Emoji.php
echo "\u{1F600}"; // Restituisce un'emoji sorridente 😀
```

---

<a id="group-use"></a>
## Dichiarazioni use di gruppo

Consentono di importare in modo pulito più classi dallo stesso namespace:

```php
// src/Controller.php
use App\Models\{User, Post, Comment};
```

---

<a id="throwable-exceptions"></a>
## Interfaccia Throwable ed eccezioni del motore

Gli errori fatali e recuperabili vengono ora generati come eccezioni di tipo **`Error`**. Catturali utilizzando l'interfaccia **`Throwable`**:

```php
// src/ErrorHandler.php
try {
    nonExistentFunction();
} catch (Throwable $t) {
    // Cattura sia gli errori del motore sia le eccezioni utente
    echo "Caught: " . $t->getMessage();
}
```

> [!NOTE]
> Lo sapevi? `Error` non estende `Exception`. La cattura di `Exception` non impedirà agli errori del motore, come la chiamata a una funzione non definita, di interrompere l'esecuzione dello script. Utilizza invece `Throwable`.

---

<a id="csprng-functions"></a>
## Funzioni CSPRNG

Generano valori casuali crittograficamente sicuri direttamente dal sistema operativo:

```php
// src/TokenGenerator.php
$bytes = random_bytes(32);
$number = random_int(1, 100);
```

Queste funzioni sostituiscono i generatori non sicuri come `rand()` o `mt_rand()` per i contesti di sicurezza.

---

<a id="common-mistakes"></a>
## ⚠️ Errori comuni

Ecco le tipiche insidie durante la migrazione a PHP 7.0:

### 1. Dimenticare di dichiarare strict types
Senza dichiarare esplicitamente strict types per file, PHP viene eseguito in modalità coercitiva e converte silenziosamente i valori degli argomenti.
```php
// src/BadStrict.php
// Errato: la modalità coercitiva è attiva, la stringa \"10\" viene convertita in intero in modo silenzioso
function setAge(int $age) {
    return $age;
}
setAge("10"); // Nessun errore generato
```
```php
// src/GoodStrict.php
// Corretto: abilita strict types all'inizio del file
declare(strict_types=1);

function setAgeGood(int $age) {
    return $age;
}
// setAgeGood("10"); // Genera TypeError
```

### 2. Catturare `Exception` per gestire gli errori del motore
Molti sviluppatori catturavano `Exception` aspettandosi che gestisse errori come la divisione per zero, il che fallisce perché gli errori del motore implementano `Error`.
```php
// src/BadCatch.php
// Errato: la divisione per zero genera un DivisionByZeroError (che estende Error), che bypassa Exception
try {
    $value = 1 / 0;
} catch (Exception $e) {
    echo "Questo blocco non viene eseguito!";
}
```
```php
// src/GoodCatch.php
// Corretto: cattura Throwable o Error per catturare gli errori del motore
try {
    $value = 1 / 0;
} catch (Throwable $e) {
    echo "Errore catturato: " . $e->getMessage();
}
```

---

<a id="limitations"></a>
## Limitazioni

* **Dichiarazioni di tipo scalare**: Non possono essere nullable per impostazione predefinita. Scrivere `int $x` e passare `null` genera un TypeError (i tipi nullable arrivano in PHP 7.1).
* **Dichiarazioni del tipo di ritorno**: Non possono essere contrassegnate come restituenti `void` (aggiunto in PHP 7.1) o tipi multipli (tipi Union aggiunti in PHP 8.0).

---

<a id="backward-incompatible"></a>
## Modifiche non retrocompatibili

### Modifiche principali

* **I tag ASP (`<% %>`) e i tag script (`<script language="php">`)** vengono completamente rimossi.
* **`$HTTP_RAW_POST_DATA`** viene rimosso; usa `php://input` al suo posto.
* **Blocchi default multipli in uno `switch`** generano un ParseError.
* **Le variabili globali e le chiamate dinamiche** vengono analizzate rigorosamente da sinistra a destra (es. `$$foo['bar']` ha un nuovo ordine di valutazione).

---

<a id="interactive-quiz"></a>
## Quiz interattivo

Metti alla prova la tua conoscenza di PHP 7.0:

1. **Quale affermazione è vera riguardo agli strict types in PHP 7.0?**
   * A) Gli strict types sono abilitati globalmente tramite php.ini.
   * B) Gli strict types devono essere dichiarati all'inizio di ogni file in cui si desidera utilizzarli.
   * C) PHP 7.0 viene eseguito solo in modalità strict e non ha una modalità coercitiva.
   * D) Gli strict types si applicano solo ai tipi di ritorno, non ai parametri.

   <details>
   <summary>Clicca per vedere la risposta</summary>
   
   **Risposta corretta: B**  
   Gli strict types vengono dichiarati per file utilizzando `declare(strict_types=1);`.
   </details>

2. **Quale classe NON estende Exception ma implementa Throwable in PHP 7.0?**
   * A) RuntimeException
   * B) Error
   * C) BadMethodCallException
   * D) InvalidArgumentException

   <details>
   <summary>Clicca per vedere la risposta</summary>
   
   **Risposta corretta: B**  
   La nuova classe `Error` e le sue sottoclassi (come `TypeError` o `ParseError`) implementano `Throwable` ma non ereditano da `Exception`.
   </details>

3. **Qual è il tipo di ritorno dell'operatore spaceship (`<=>`)?**
   * A) Booleano
   * B) Float
   * C) Intero (`-1`, `0` o `1`)
   * D) Stringa

   <details>
   <summary>Clicca per vedere la risposta</summary>
   
   **Risposta corretta: C**  
   L'operatore spaceship confronta due valori e restituisce `-1` se quello a sinistra è più piccolo, `0` se sono uguali e `1` se quello a sinistra è più grande.
   </details>

---

<a id="closing-thoughts"></a>
## Considerazioni finali

PHP 7.0 è una **pietra miliare rivoluzionaria** nello sviluppo web. Assicurati che il tuo server esegua Zend Engine 3, aggiorna la tua codebase legacy rimuovendo i tag ASP, converti le funzioni casuali non sicure negli equivalenti CSPRNG e riscrivi le catture di Exception in Throwable.