Il sistema dei tipi di PHP

In breve: PHP è tipizzato dinamicamente: il tipo di un valore è definito solo in fase di esecuzione e, senza ulteriori indicazioni, PHP converte automaticamente i valori quando serve. Da PHP 7, però, parametri, valori di ritorno e proprietà possono essere dotati di tipi, e declare(strict_types=1) rende rigoroso il controllo. Chi conosce le regole e usa confronti stretti con === evita un'intera classe di errori di logica e di sicurezza.

Tipizzato dinamicamente, ma non privo di tipi

In PHP, con $preis = 19.90; non occorre indicare alcun tipo. PHP riconosce che si tratta di un numero in virgola mobile. Se il valore viene poi concatenato a una stringa, PHP lo converte. Questo comportamento si chiama type juggling, cioè conversione automatica dei tipi. Rende facile iniziare, ma può portare a risultati sorprendenti.

Per chi decide è rilevante perché molte applicazioni PHP più vecchie sono state scritte senza indicazioni di tipo. Un codice del genere è più difficile da verificare e da modernizzare. I progetti più recenti usano i tipi in modo coerente, il che rende gli errori visibili prima e permette all'analisi statica con strumenti come PHPStan o Psalm di dare davvero il meglio.

I tipi di PHP in sintesi

Il manuale PHP indica nove tipi interni che ogni espressione può avere. Di solito vengono suddivisi in tre gruppi:

Per i controlli di tipo il manuale raccomanda le funzioni is_*(), come is_int(). Per l'analisi è adatta get_debug_type(), che da PHP 8.0.0 restituisce i nomi di tipo di uso comune, mentre la più vecchia gettype() restituisce ad esempio "integer" e "double".

Accanto alla conversione automatica esiste quella esplicita: con un cast come (int) $wert o con settype() è il codice stesso a stabilire quale tipo debba avere un valore. È una pratica comune per i dati dei moduli, perché tutto ciò che arriva tramite $_GET o $_POST è inizialmente una stringa o un array. Un cast, però, non verifica se il valore avesse senso: da "abc" si ottiene in silenzio 0. Per i dati in ingresso, un vero controllo con filter_var() è quindi di solito la scelta migliore.

Anche classi e interfacce sono tipi in PHP. Una funzione può quindi richiedere che un parametro sia un oggetto di una determinata classe o che soddisfi una determinata interfaccia. Come interagiscono classi, interfacce ed enum lo spiega la pagina Programmazione a oggetti in PHP.

Dichiarazioni di tipo: da PHP 7.1 a 8.3

Le dichiarazioni di tipo stabiliscono quali valori una funzione accetta e restituisce. Il sistema dei tipi è cresciuto nel corso di molte versioni. Secondo il registro delle modifiche del manuale sono state aggiunte, tra le altre, queste possibilità:

DNF sta per forma normale disgiuntiva e consente combinazioni come (A&B)|null. Chi pianifica le versioni di PHP vede da questa tabella anche quali strumenti del linguaggio un'applicazione presuppone.

strict_types: conversione o TypeError

Senza altre indicazioni PHP lavora in modalità con conversione. Una funzione con parametri int accetta allora anche 1.5 e ne ricava 1; da PHP 8.1 questa conversione con perdita è contrassegnata come deprecata. Con declare(strict_types=1) all'inizio del file, PHP genera invece un TypeError.

<?php
declare(strict_types=1);

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

echo summe(1, 2);      // 3
echo summe(1.5, 2.5);  // TypeError, invece di 3 in silenzio

Due sfumature sono importanti. Primo: strict_types vale per le chiamate effettuate dal file in cui compare, non per le funzioni ivi definite. Se un file senza strict_types chiama la stessa funzione, si converte. Secondo: un intero dove ci si aspetta un numero in virgola mobile è ammesso anche in modalità rigorosa.

Confronti non rigorosi e rigorosi

L'operatore == confronta dopo la conversione di tipo, === confronta valore e tipo senza conversione. Il manuale raccomanda nella maggior parte dei casi === e !==, perché le regole di conversione non sono sempre evidenti.

<?php
var_dump(0 == "a");    // PHP 7: true,  PHP 8: false
var_dump("1" == "01"); // true, entrambe sono stringhe numeriche
var_dump("1" === "01");// false, stesso tipo, ma un'altra stringa
var_dump(1 == true);   // true
var_dump(1 === true);  // false

Con PHP 8.0 i confronti tra numeri e stringhe non numeriche sono diventati più sensati. Le applicazioni più vecchie possono comportarsi in modo diverso dopo l'upgrade, ad esempio nei blocchi switch. L'espressione match, introdotta anch'essa con PHP 8.0, confronta sempre in modo rigoroso. Come i confronti non rigorosi portino a vulnerabilità, ad esempio nei controlli di token o password, lo descrive l'articolo Type juggling: i confronti non rigorosi come rischio per la sicurezza.

Tipi, upgrade e PHP2Shell

Un sistema dei tipi rigoroso rende il codice applicativo più robusto, ma non protegge dagli errori nell'interprete stesso. Le vulnerabilità PHP2Shell CVE-2026-109618 e CVE-2026-109619 si trovano nella gestione della memoria e delle richieste di PHP. Sono corrette in PHP 8.5.12, 8.4.27, 8.3.36 e 8.2.35; in seguito tutti i processi PHP devono essere riavviati.

Il sistema dei tipi gioca comunque un ruolo, e precisamente nell'upgrade. Le applicazioni ancora ferme a PHP 8.1 o precedenti non ricevono più aggiornamenti ufficiali dal progetto PHP. Un codice ben tipizzato è molto più facile da portare a una versione supportata, perché gli strumenti individuano per tempo le incompatibilità. Per i progetti più datati è utile la nostra migrazione a una versione di PHP supportata.

Come aiuta concretamente PHP SOS?

• Verifichiamo quale versione di PHP la Sua applicazione richiede come minimo e la confrontiamo con le versioni corrette.
• Eseguiamo l'analisi statica sul codice e segnaliamo i punti con confronti non rigorosi in controlli rilevanti per la sicurezza.
• Pianifichiamo gli upgrade in modo che le regole di confronto modificate vengano testate prima.
• Installiamo l'aggiornamento di PHP, riavviamo tutti i worker e documentiamo lo stato.

Domande frequenti

Fonti

• Manuale PHP: dichiarazioni di tipo
• Manuale PHP: introduzione ai tipi
• Manuale PHP: operatori di confronto
• Rilascio di PHP 8.0