---
title: 'PHP 5.3: Namespaces, Closures, Late Static Binding & Migration | DevSense'
description: "Guida all'aggiornamento per PHP 5.3: padroneggia namespace, late static binding, closure, NOWDOC, Phar e garbage collection dei cicli evitando i fatal break di retrocompatibilità."
faq:
    - { question: "Cos'è il Late Static Binding (LSB) in PHP 5.3?", answer: 'Il Late Static Binding consente di fare riferimento alla classe chiamata in un contesto statico utilizzando la parola chiave `static::` invece di `self::`, che punta sempre alla classe in cui il metodo è definito.' }
    - { question: 'Perché il passaggio per riferimento al momento della chiamata è stato rimosso in PHP 5.3?', answer: 'È stato rimosso perché rendeva le firme delle funzioni ambigue e difficili da ottimizzare. I parametri devono essere dichiarati come riferimenti nella definizione della funzione, non al momento della chiamata.' }
    - { question: 'Qual è la differenza tra HEREDOC e NOWDOC?', answer: "HEREDOC analizza le variabili all'interno del blocco di testo, mentre NOWDOC (definito con virgolette singole attorno all'identificatore, come <<<'EOT') tratta il testo come una stringa grezza senza analizzare le variabili." }
    - { question: 'Come funziona il garbage collector dei cicli di riferimento opzionale?', answer: 'Rileva e pulisce i riferimenti circolari (oggetti che si riferiscono a vicenda) che il conteggio dei riferimenti standard non può liberare, prevenendo perdite di memoria nei processi a lungo termine.' }
published: '2026-05-31'
---
# PHP 5.3: Modernizzazione e Fondamenta Enterprise

Immagina di aggiornare il tuo server e di trovarti improvvisamente davanti a una schermata bianca (white screen of death) perché una libreria di terze parti utilizzava una parola non quotata o un riferimento in una chiamata di funzione. PHP 5.3 è stato il punto di svolta in cui il linguaggio ha smesso di essere un semplice motore di scripting per trasformarsi in un linguaggio OOP maturo e di livello enterprise. Tuttavia, questa transizione ha comportato importanti modifiche non retrocompatibili che hanno compromesso il funzionamento di migliaia di applicazioni legacy da un giorno all'altro.

Prima di PHP 5.3, gli sviluppatori lottavano contro collisioni globali dei nomi delle classi, un'ereditarietà interrotta dei metodi statici e perdite di memoria incontrollabili negli script a lungo termine causate da cicli di riferimento. Per risolvere questo problema, PHP 5.3 ha introdotto namespace, closure, late static binding e un garbage collector con rilevamento dei cicli. Ha inoltre eliminato funzionalità legacy come il passaggio per riferimento al momento della chiamata e l'estensione `ereg`.

> [!IMPORTANT]
> PHP 5.3 è la pietra miliare del moderno PHP orientato agli oggetti, spingendo gli sviluppatori ad abbandonare le abitudini di PHP 4 in favore dell'isolamento dei namespace e di una gestione strutturata della memoria.

---

## Indice
* [Namespace e Autoloading](#namespaces)
* [Late Static Binding (`static::`)](#lsb)
* [Closure e la clausola `use`](#closures)
* [NOWDOC vs HEREDOC](#syntax-additions)
* [Garbage Collection dei cicli di riferimento](#gc)
* [Errori comuni](#common-mistakes)
* [Ricette pratiche](#practical-recipes)
* [Modifiche non retrocompatibili](#backward-incompatible)
* [🧠 Domande di autovalutazione](#self-check)

---

<a id="namespaces"></a>
## Namespace e Autoloading

I namespace isolano il codice ed evitano l'uso di prefissi infiniti per i nomi delle classi.

```php
// app/Repositories/UserRepository.php
namespace App\Repositories;

use App\Database\Connection;
use App\Contracts\LoggerInterface;

class UserRepository
{
    private Connection $db;
    private LoggerInterface $log;

    public function __construct(Connection $db, LoggerInterface $log)
    {
        $this->db = $db;
        $this->log = $log;
    }
}
```

* **Perché è importante**: Prima dei namespace, le collisioni tra nomi di classi venivano evitate nominando i file e le classi con lunghe stringhe di prefissi (es. `Zend_Db_Table_Row_Abstract`). I namespace rendono il codice pulito e leggibile, consentendo nomi di classi più brevi e isolati logicamente.
* **Conseguenza**: Questa funzionalità ha gettato le basi per i moderni pacchetti PHP, per l'autoloading standard (PSR-0/PSR-4) e per la creazione di Composer.

---

<a id="lsb"></a>
## Late Static Binding (`static::`)

In PHP, `self::` si risolve sempre nella classe in cui il metodo è stato definito. Il Late Static Binding introduce `static::`, che fa riferimento alla classe effettivamente chiamata a runtime.

```php
// app/Models/ActiveRecord.php
abstract class ActiveRecord
{
    public static function find(int $id): string
    {
        // self::getTable() qui fallirebbe per le sottoclassi
        return "SELECT * FROM " . static::getTable() . " WHERE id = " . $id;
    }

    abstract protected static function getTable(): string;
}
```

* **Perché è importante**: Senza LSB, scrivere classi di base estensibili con metodi factory statici (come gli ORM Active Record) era estremamente problematico.
* **Conseguenza**: Gli sviluppatori possono scrivere eleganti helper nella classe genitore che interagiscono correttamente con le proprietà o i metodi statici sovrascritti nel contesto delle sottoclassi.

---

<a id="closures"></a>
## Closure e la clausola `use`

Le funzioni anonime possono ora essere assegnate a variabili, passate come argomenti e catturare variabili dall'ambito genitore utilizzando la parola chiave `use`.

```php
// app/Services/Calculator.php
$taxRate = 0.20;

$calculateTotal = function (float $price) use ($taxRate): float {
    return $price * (1 + $taxRate);
};

echo $calculateTotal(100); // 120
```

> [!NOTE]
> In PHP 5.3, le closure catturano le variabili ereditate **per valore** per impostazione predefinita. Se è necessario modificare la variabile originale all'interno della closure, occorre passarla **per riferimento** (es. `use (&$counter)`).

---

<a id="syntax-additions"></a>
## NOWDOC vs HEREDOC

NOWDOC sta a HEREDOC come le stringhe a virgolette singole stanno alle stringhe a virgolette doppie.

```php
// app/Config/templates.php
// HEREDOC (analizza le variabili)
$name = 'John';
$heredoc = <<<EOT
Hello $name!
EOT;

// NOWDOC (non analizza le variabili, nota le virgolette singole attorno a EOT)
$nowdoc = <<<'EOT'
Hello $name!
EOT;
```

* **Perché è importante**: NOWDOC rende sicuro l'inserimento di blocchi grezzi di configurazione, script di shell o espressioni regolari senza dover effettuare l'escape del simbolo del dollaro.

---

<a id="gc"></a>
## Garbage Collection dei cicli di riferimento

PHP 5.3 ha introdotto un rilevatore di riferimenti circolari. Quando l'oggetto A punta all'oggetto B e l'oggetto B punta all'oggetto A, il conteggio dei riferimenti standard non riesce a ripulirli, anche se non sono più raggiungibili.

```php
// app/Services/Daemon.php
gc_enable(); // Abilita il rilevatore di riferimenti circolari

// In un processo a lungo termine:
gc_collect_cycles(); // Forza la raccolta dei cicli per la pulizia della memoria
```

* **Perché è importante**: Essenziale per worker di code in background, comandi CLI e daemon a lungo termine che altrimenti esaurirebbero la memoria.

---

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

### 1. Passaggio per riferimento al momento della chiamata
Il passaggio di variabili con una e commerciale (`&`) nelle chiamate di funzione causa errori fatali.

```php
// app/Services/LegacyFix.php
// ❌ Deprecato / Errore fatale in PHP 5.3+
foo(&$value); 

// ✅ Approccio corretto
// Il riferimento deve essere definito nella firma del metodo:
function foo(&$param) {}
foo($value); 
```

### 2. Uso di parole chiave riservate come identificatori
Nuove parole chiave come `goto`, `namespace` e `use` non possono essere utilizzate come nomi di classi o costanti non racchiuse tra virgolette.

```php
// app/Classes/Runner.php
// ❌ Errore fatale: Impossibile utilizzare 'goto' come nome di classe
class goto {}
```

### 3. Miscelazione di espressioni regolari POSIX e PCRE
L'uso di funzioni `ereg()` al posto di `preg_match()`. Le funzioni POSIX sono deprecate in PHP 5.3 e rimosse in PHP 7.0.

```php
// app/Validation/Email.php
// ❌ Deprecato in PHP 5.3
if (eregi('^[a-z0-9]+$', $input)) {}

// ✅ Approche corretto
if (preg_match('/^[a-z0-9]+$/i', $input)) {}
```

---

<a id="practical-recipes"></a>
## Ricette pratiche

### Aspettative vs Realtà: `self` vs `static`

```php
// app/Demo/BindingDemo.php
class ParentClass
{
    public static function getClassName(): string
    {
        return self::class; // O __CLASS__
    }

    public static function getCalledClassName(): string
    {
        return static::class;
    }
}

class ChildClass extends ParentClass {}

// Aspettativa: Entrambi restituiscono 'ChildClass'
// Realtà:
echo ChildClass::getClassName();       // Output: ParentClass
echo ChildClass::getCalledClassName(); // Output: ChildClass
```

---

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

1. **Rimozione del passaggio per riferimento al momento della chiamata**: La sintassi `foo(&$x)` è deprecata ed emette avvisi in PHP 5.3 (rimossa completamente in PHP 5.4).
2. **Nuove parole riservate**: `goto`, `namespace`, `use`, `const` non possono essere usati come nomi di classe, interfaccia o costanti.
3. **Deprecazione della famiglia `ereg`**: L'utilizzo delle funzioni regex `ereg_*` solleva avvisi di tipo `E_DEPRECATED`.
4. **Rigidità dell'ordine dei parametri**: Funzioni come `clearstatcache()` e varie utility matematiche hanno ristretto le regole di convalida dei parametri.

---

## 🧠 Domande di autovalutazione

1. **Vero o Falso?** In PHP 5.3, le closure associano automaticamente il contesto `$this` quando vengono definite all'interno di un metodo di un oggetto.
2. Come si dichiara un blocco di testo NOWDOC?
3. Qual è la differenza tra `self::` e `static::` nel Late Static Binding?
4. Cosa succede se si tenta di chiamare una funzione usando `bar(&$var)` in PHP 5.3?

<details>
<summary><b>Mostra risposte</b></summary>

1. **Falso.** In PHP 5.3, le closure NON associano `$this` automaticamente. È necessario passare manualmente l'oggetto (es. `$self = $this;` e `use ($self)`) per accedere alle variabili di istanza. L'associazione automatica di `$this` nelle closure è stata introdotta in PHP 5.4.
2. Racchiudere l'identificatore tra virgolette singole nel tag di apertura: `<<<'EOT'`.
3. `self::` si riferisce alla classe in cui il codice è stato compilato (la classe in cui è definito), mentre `static::` si riferisce dinamicamente alla classe effettivamente chiamata a runtime.
4. Verrà emesso un avviso di deprecazione (`Deprecated: Call-time pass-by-reference has been deprecated...`). In PHP 5.4+ questa sintassi genera un errore di sintassi fatale.
</details>