Operatory porównania w PHP: == vs === i <=>

== sprawdza, czy dwie wartości są równe po tym, jak PHP skonwertuje je do wspólnego typu. === sprawdza, czy są równe i tego samego typu. Dlatego 1 == "1" daje true, a 1 === "1" daje 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

Większość błędów z porównaniami bierze się z tego, że == konwertuje coś, czego się nie spodziewałeś. Dobrym domyślnym wyborem są === i !==, a == tylko wtedy, gdy wiesz, że chcesz konwersji.

Wszystkie operatory porównania w PHP

Tabela porównań luźnych i ścisłych

Każdą komórkę tej tabeli obliczyło PHP 8.3. Przełączaj między == i === i kliknij komórkę, aby zobaczyć wyrażenie. Siatka == jest pełna niespodzianek w wierszach dla null, "", "0" i []; siatka === to tylko jej przekątna.

Jak == porównuje różne typy

Zasady, których przestrzega PHP 8, w kolejności, w jakiej mają znaczenie w praktyce:

1. Dwa łańcuchy liczbowe są porównywane jak liczby: "10" == "1e1" i "1" == "01" dają true.
2. Liczba i łańcuch liczbowy: łańcuch staje się liczbą. 100 == "1e2" daje true.
3. Liczba i łańcuch nieliczbowy: od PHP 8 liczba staje się łańcuchem i porównuje się je jako łańcuchy. 0 == "a" daje false (w PHP 7 dawało true).
4. Cokolwiek i bool: obie strony są konwertowane na bool. "a" == true i [] == false dają true.
5. null i łańcuch: null staje się "", więc null == "" daje true, ale null == "0" daje false. Względem każdego innego typu null jest porównywane jako false.
6. Dwie tablice: są równe, gdy mają te same pary klucz/wartość.

<?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

Ostatnia linia pokazuje, dlaczego porównania kolejności z null rzadko mają sens: null staje się false, -1 staje się true, a false < true.

Różne: != vs !==

!= i <> to ten sam operator. !== to wersja ścisła. Różnica ma największe znaczenie przy funkcjach, które zwracają 0 albo false, takich jak 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 daje false, bo 0 konwertuje się na false. 0 !== false daje true, bo int to nie bool. Ta sama pułapka dotyczy array_search i in_array bez flagi strict.

Porównywanie łańcuchów

< i > porównują łańcuchy bajt po bajcie (alfabetycznie dla zwykłego ASCII). Jeśli oba łańcuchy są liczbowe, porównuje się je jak liczby. Do porównania bez rozróżniania wielkości liter albo w porządku „naturalnym” użyj funkcji:

<?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

Operator spaceship <=>

$a <=> $b zwraca -1, gdy $a jest mniejsze, 0, gdy są równe, i 1, gdy $a jest większe. Stosuje te same zasady co < i == i jest najkrótszym sposobem zapisu funkcji porównującej do sortowania.

<?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";

Porównanie dwóch tablic przez <=> porównuje je element po elemencie i właśnie tak funkcja sortuje najpierw po wieku, a potem po imieniu. Więcej przepisów na sortowanie jest na stronie o sortowaniu tablic.

Częsty błąd: porównywanie floatów przez ==

Floaty są przechowywane binarnie, więc wiele wartości dziesiętnych to przybliżenia. 0.1 + 0.2 to nie dokładnie 0.3, a == widzi tę różnicę.

<?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));

Kwoty pieniężne przechowuj jako całe grosze w liczbach całkowitych i porównuj je przez ===.