Operatore di identità e uguaglianza in PHP: confronti sicuri tra valori

Introduzione

Quando si lavora con PHP, uno degli errori più comuni è pensare che due valori “uguali” siano sempre anche “identici”. In realtà, PHP distingue tra uguaglianza e identità, e questa differenza è fondamentale per scrivere codice corretto, soprattutto quando si gestiscono input utente, dati provenienti da database, form, API o sessioni.

In questo tutorial vedremo in modo pratico l’uso degli operatori ==, ===, !=, !==, con particolare attenzione al confronto rigoroso tramite identità. È un sotto-argomento molto utile perché aiuta a evitare bug difficili da individuare, come falsi positivi nei controlli condizionali o risultati inattesi nei confronti tra stringhe, numeri e valori booleani.

Capire bene questi operatori è una competenza essenziale per chi sviluppa in PHP in modo professionale. Il tema è semplice in apparenza, ma nella pratica fa la differenza tra un codice fragile e uno affidabile.

Codice completo

<?php

// Esempio 1: confronto tra stringa e numero
$valoreDaForm = "10";
$numero = 10;

if ($valoreDaForm == $numero) {
    echo "Con == i valori risultano ugualin";
}

if ($valoreDaForm === $numero) {
    echo "Con === i valori risultano identicin";
} else {
    echo "Con === i valori NON sono identicin";
}

// Esempio 2: confronto con zero e stringhe vuote
$input = "0";

if ($input == false) {
    echo ""0" è considerato uguale a false con ==n";
}

if ($input === false) {
    echo ""0" è identico a false con ===n";
} else {
    echo ""0" non è identico a false con ===n";
}

// Esempio 3: controllo su un valore restituito da una funzione
function cercaUtente(int $id): int|false
{
    $utenti = [1 => 1001, 2 => 1002, 3 => 1003];
    return $utenti[$id] ?? false;
}

$utente = cercaUtente(2);

if ($utente !== false) {
    echo "Utente trovato con ID interno: " . $utente . "n";
} else {
    echo "Utente non trovaton";
}

// Esempio 4: confronto di array
$profiloA = [
    ´nome´ => ´Luca´,
    ´ruolo´ => ´admin´
];

$profiloB = [
    ´ruolo´ => ´admin´,
    ´nome´ => ´Luca´
];

if ($profiloA == $profiloB) {
    echo "Gli array hanno gli stessi valorin";
}

if ($profiloA === $profiloB) {
    echo "Gli array sono identici anche nell´ordine e nei tipin";
} else {
    echo "Gli array non sono identici con ===n";
}

// Esempio 5: confronto di oggetti
class Prodotto
{
    public function __construct(
        public string $sku,
        public string $nome
    ) {}
}

$prodotto1 = new Prodotto(´ABC123´, ´Mouse´);
$prodotto2 = new Prodotto(´ABC123´, ´Mouse´);
$prodotto3 = $prodotto1;

if ($prodotto1 == $prodotto2) {
    echo "I due oggetti hanno gli stessi attributin";
}

if ($prodotto1 === $prodotto2) {
    echo "Gli oggetti sono la stessa istanzan";
} else {
    echo "Gli oggetti non sono la stessa istanzan";
}

if ($prodotto1 === $prodotto3) {
    echo "prodotto1 e prodotto3 sono la stessa istanzan";
}

Spiegazione

In PHP, l’operatore == verifica se due valori sono uguali dopo eventuali conversioni di tipo. Questo comportamento viene chiamato confronto lento o non rigoroso. PHP prova a rendere compatibili i due valori prima di confrontarli. È comodo, ma può generare risultati inattesi.

L’operatore ===, invece, confronta sia il valore sia il tipo. Questo è il confronto rigoroso o identico. Se una variabile contiene la stringa "10" e l’altra il numero intero 10, con == il confronto può risultare vero, ma con === sarà falso perché i tipi sono diversi.

Lo stesso discorso vale per gli operatori negativi:

• != significa “diverso” con conversione implicita dei tipi.
• !== significa “non identico”, quindi diverso per valore o tipo.

Un caso molto importante riguarda i valori come 0, "0", false, null e "". In PHP questi valori possono essere facilmente confusi nei confronti non rigorosi. Per esempio, la stringa "0" può comportarsi in modo sorprendente se confrontata con false usando ==. Per questo, quando il tipo conta davvero, conviene usare sempre === o !==.

Nel codice completo abbiamo anche confronti tra array e oggetti. Per gli array, == verifica che abbiano gli stessi elementi e valori, anche se l’ordine delle chiavi può influire in alcuni casi particolari. Con ===, invece, PHP controlla che gli array siano uguali nei valori, nei tipi e anche nell’ordine delle chiavi. È quindi un controllo più severo.

Per gli oggetti, == confronta gli attributi e i loro valori, mentre === verifica se le due variabili puntano alla stessa istanza in memoria. Questo è molto utile quando vuoi sapere se stai lavorando con lo stesso oggetto o con due oggetti distinti ma simili.

Il caso della funzione cercaUtente() mostra un pattern reale e molto frequente: una funzione può restituire un valore utile oppure false per indicare che qualcosa non è andato a buon fine. In questi casi è importante usare !== false, così eviti che valori validi ma “falsi” per PHP vengano interpretati come errore.

Best practice

• Preferisci sempre === e !== quando non hai una ragione precisa per usare il confronto non rigoroso.
• Evita == nei controlli critici, soprattutto con input utente, ID, flag booleani e risultati di funzioni.
• Controlla i tipi dei dati prima di confrontarli, specialmente se arrivano da form HTML o database.
• Usa confronti espliciti con false, null e stringhe vuote per ridurre ambiguità.
• Ricorda che gli oggetti non si confrontano come i numeri: con === verifichi l’identità dell’istanza, non solo il contenuto.
• Nei test automatici, usa confronti rigorosi per intercettare subito differenze di tipo non desiderate.

Una buona regola pratica è questa: se stai confrontando dati che devono essere esattamente uguali, usa ===. Se invece stai facendo un controllo molto specifico e conosci bene il comportamento del tipo coinvolto, puoi valutare ==, ma con cautela.

Riepilogo

Gli operatori di confronto in PHP sono strumenti fondamentali per prendere decisioni corrette nel codice. La differenza tra uguaglianza e identità è semplice da capire, ma molto importante da applicare bene.

• == confronta i valori con conversione implicita.
• === confronta valore e tipo in modo rigoroso.
• != è la negazione di ==.
• !== è la negazione di ===.

Se vuoi scrivere codice PHP più sicuro e prevedibile, fai dell’operatore === il tuo punto di riferimento. Ti aiuterà a evitare bug sottili e renderà il comportamento del programma più chiaro sia per te sia per chi leggerà il codice dopo di te.

Approfondisci con risorse ufficiali

• Manuale PHP - Operatori di confronto: documentazione ufficiale sugli operatori ==, ===, !=, !== e altri confronti.
• Manuale PHP - Tipi di dati: utile per capire come PHP gestisce stringhe, interi, booleani, array e oggetti.
• Manuale PHP - Confronto tra array: approfondimento sul comportamento degli array con operatori di uguaglianza e identità.
• Manuale PHP - Oggetti: per capire meglio come funziona il confronto tra istanze.