אופרטורי השוואה ב-PHP: == מול === ו-<=>

== בודק אם שני ערכים שווים אחרי ש-PHP ממיר אותם לטיפוס משותף. === בודק שהם שווים וגם מאותו טיפוס. לכן 1 == "1" הוא true, בעוד 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

רוב הבאגים בהשוואות נובעים מכך ש-== ממיר משהו שלא ציפיתם לו. ברירת מחדל טובה היא === ו-!==, ומעבר ל-== רק כשאתם יודעים שאתם רוצים את ההמרה.

כל אופרטורי ההשוואה ב-PHP

טבלת השוואה רופפת ומחמירה

כל תא בטבלה הזו חושב על ידי PHP 8.3. עברו בין == ל-=== והקישו על תא כדי לראות את הביטוי. הרשת של == מלאה בהפתעות בשורות של null, "", "0" ו-[]; הרשת של === היא רק האלכסון שלה.

איך == משווה טיפוסים שונים

הכללים ש-PHP 8 פועלת לפיהם, בסדר שבו הם משנים בפועל:

1. שתי מחרוזות מספריות מושוות כמספרים: "10" == "1e1" וגם "1" == "01" הם true.
2. מספר ומחרוזת מספרית: המחרוזת הופכת למספר. 100 == "1e2" הוא true.
3. מספר ומחרוזת לא מספרית: מאז PHP 8, המספר הופך למחרוזת והם מושווים כמחרוזות. 0 == "a" הוא false (ב-PHP 7 זה היה true).
4. כל דבר מול bool: שני הצדדים מומרים ל-bool. "a" == true וגם [] == false הם true.
5. null ומחרוזת: null הופך ל-"", ולכן null == "" הוא true אבל null == "0" הוא false. מול כל טיפוס אחר, null מושווה כ-false.
6. שני מערכים: שווים כשיש להם אותם זוגות מפתח/ערך.

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

השורה האחרונה מראה למה השוואות סדר עם null נדירות שיש בהן היגיון: null הופך ל-false, -1 הופך ל-true, ו-false < true.

אי שוויון: != מול !==

!= ו-<> הם אותו אופרטור. !== הוא הגרסה המחמירה. ההבדל חשוב במיוחד עם פונקציות שמחזירות 0 או false, כמו 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 כי 0 מומר ל-false. 0 !== false הוא true כי int הוא לא bool. אותה מלכודת קיימת ב-array_search וב-in_array בלי הדגל המחמיר שלה.

השוואת מחרוזות

< ו-> משווים מחרוזות בית אחר בית (לפי סדר האלף בית ב-ASCII רגיל). אם שתי המחרוזות מספריות, הן מושוות כמספרים. לסדר שלא תלוי באותיות גדולות וקטנות, או לסדר "טבעי", השתמשו בפונקציות:

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

אופרטור החללית <=>

$a <=> $b מחזיר -1 כש-$a קטן יותר, 0 כשהם שווים ו-1 כש-$a גדול יותר. הוא פועל לפי אותם כללים כמו < ו-==, וזו הדרך הקצרה ביותר לכתוב callback למיון.

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

השוואת שני מערכים עם <=> משווה אותם איבר אחר איבר, וכך ה-callback ממיין קודם לפי גיל ואחר כך לפי שם. מתכונים נוספים למיון נמצאים בעמוד מיון מערכים.

טעות נפוצה: השוואת floats עם ==

floats נשמרים בבינארי, ולכן ערכים עשרוניים רבים הם קירובים. 0.1 + 0.2 הוא לא בדיוק 0.3, ו-== רואה את ההפרש.

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

לכסף, שמרו סנטים שלמים כמספרים שלמים והשוו אותם עם ===.