Operatori di confronto PHP: == vs === e <=>

== controlla se due valori sono uguali dopo che PHP li ha convertiti a un tipo comune. === controlla che siano uguali e dello stesso tipo. Quindi 1 == "1" è true, mentre 1 === "1" è false.

<?php
var_dump(1 == "1");      // same value after conversion
var_dump(1 === "1");     // int vs string
var_dump(0 == false);
var_dump(0 === false);
var_dump(null == false);
var_dump("abc" == "ABC"); // case matters

La maggior parte dei bug nei confronti nasce da == che converte qualcosa che non ti aspettavi. Una buona scelta predefinita è === e !==, passando a == solo quando sai di volere la conversione.

Tutti gli operatori di confronto PHP

Tabella dei confronti stretti e non stretti

Ogni cella di questa tabella è stata calcolata da PHP 8.3. Passa da == a === e tocca una cella per vedere l'espressione. La griglia di == è piena di sorprese nelle righe di null, "", "0" e []; quella di === è solo la sua diagonale.

Come == confronta tipi diversi

Le regole che segue PHP 8, nell'ordine in cui contano nella pratica:

1. Due stringhe numeriche vengono confrontate come numeri: "10" == "1e1" e "1" == "01" sono entrambi true.
2. Un numero e una stringa numerica: la stringa diventa un numero. 100 == "1e2" è true.
3. Un numero e una stringa non numerica: da PHP 8, il numero diventa una stringa e vengono confrontati come stringhe. 0 == "a" è false (in PHP 7 era true).
4. Qualsiasi valore e un bool: entrambi i lati vengono convertiti in bool. "a" == true e [] == false sono true.
5. null e una stringa: null diventa "", quindi null == "" è true ma null == "0" è false. Contro qualsiasi altro tipo, null viene confrontato come false.
6. Due array: sono uguali quando hanno le stesse coppie chiave/valore.

<?php
var_dump("10" == "1e1");   // both numeric strings
var_dump("1" == "01");
var_dump(100 == "1e2");
var_dump(0 == "a");        // false since PHP 8
var_dump("1" == " 1");     // whitespace around a number is allowed
var_dump([] == false);     // empty array is falsy
var_dump(null == "0");     // null becomes "", and "" is not "0"
var_dump(null < -1);       // null and -1 become false < true

L'ultima riga mostra perché i confronti d'ordine con null hanno raramente senso: null diventa false, -1 diventa true, e false < true.

Diverso: != vs !==

!= e <> sono lo stesso operatore. !== è la versione stretta. La differenza conta soprattutto con le funzioni che restituiscono 0 o false, come strpos:

<?php
$text = "php is fun";
$pos = strpos($text, "php");   // found at position 0

if ($pos != false) {
    echo "!= says found\n";
} else {
    echo "!= says NOT found (wrong)\n";
}

if ($pos !== false) {
    echo "!== says found at $pos\n";
}

0 != false è false perché 0 si converte in false. 0 !== false è true perché un int non è un bool. La stessa trappola vale per array_search e per in_array senza il suo flag strict.

Confrontare stringhe

< e > confrontano le stringhe byte per byte (in ordine alfabetico per il semplice ASCII). Se entrambe le stringhe sono numeriche, vengono confrontate come numeri. Per un ordine senza distinzione tra maiuscole e minuscole o "naturale" usa le funzioni:

<?php
var_dump("apple" < "banana");
var_dump("10" < "9");      // both numeric: 10 < 9
var_dump("10" < "9a");     // not both numeric: compared as text

var_dump(strcmp("a", "b"));            // < 0
var_dump(strcasecmp("HELLO", "hello")); // 0 means equal
var_dump(strnatcmp("img12", "img10"));  // natural order

L'operatore spaceship <=>

$a <=> $b restituisce -1 quando $a è più piccolo, 0 quando sono uguali e 1 quando $a è più grande. Usa le stesse regole di < e ==, ed è il modo più breve per scrivere una callback di ordinamento.

<?php
var_dump(1 <=> 2, 2 <=> 2, 3 <=> 2);
var_dump("a" <=> "b");
var_dump([1, 2] <=> [1, 3]);

$people = [
    ["name" => "Ada", "age" => 36],
    ["name" => "Linus", "age" => 28],
    ["name" => "Grace", "age" => 85],
];

// sort by age, then by name
usort($people, fn($a, $b) => [$a["age"], $a["name"]] <=> [$b["age"], $b["name"]]);
echo implode(", ", array_column($people, "name")), "\n";

Confrontare due array con <=> li confronta elemento per elemento, ed è così che la callback ordina prima per età e poi per nome. Altre ricette di ordinamento sono nella pagina sull'ordinamento degli array.

Errore comune: confrontare float con ==

I float sono memorizzati in binario, quindi molti valori decimali sono approssimazioni. 0.1 + 0.2 non è esattamente 0.3, e == vede la differenza.

<?php
$sum = 0.1 + 0.2;

var_dump($sum == 0.3);
var_dump($sum);

// Compare with a tolerance
var_dump(abs($sum - 0.3) < PHP_FLOAT_EPSILON);

// Or round to the precision you need, e.g. money in cents
var_dump(round($sum, 2) == round(0.3, 2));

Per i soldi, memorizza i centesimi come interi e confrontali con ===.