אופרטורים ב-PHP: חשבון, לוגיקה, מחרוזות ועוד

אופרטור מקבל ערך אחד או יותר ומייצר ערך חדש: $a + $b מחבר, $a . $b משרשר מחרוזות, $a && $b הוא AND לוגי, $a === $b משווה, $i++ מגדיל.

<?php
$a = 17;
$b = 5;

echo "a + b  = ", $a + $b, "\n";
echo "a - b  = ", $a - $b, "\n";
echo "a * b  = ", $a * $b, "\n";
echo "a / b  = ", $a / $b, "\n";
echo "a % b  = ", $a % $b, "\n";
echo "a ** 2 = ", $a ** 2, "\n";
echo "intdiv = ", intdiv($a, $b), "\n";

/ מחזיר float אלא אם שני מספרים שלמים מתחלקים ללא שארית: 17 / 5 הוא 3.4, 10 / 5 הוא המספר השלם 2. כשרוצים רק את החלק השלם, השתמשו ב-intdiv(). עיגול מוסבר בעמוד המתמטיקה.

אופרטורים חשבוניים

מודולו שימושי ל"כל פריט N" ולבדיקות זוגי ואי זוגי. התוצאה שלו מקבלת את הסימן של הצד השמאלי, וחלוקה באפס זורקת שגיאה שאפשר לתפוס:

<?php
for ($i = 1; $i <= 6; $i++) {
    echo $i, $i % 2 === 0 ? " even" : " odd", "\n";
}

var_dump(-7 % 3);
var_dump(fmod(7.5, 2));   // modulo for floats

try {
    echo 10 % 0;
} catch (DivisionByZeroError $e) {
    echo "Error: ", $e->getMessage(), "\n";
}

אופרטורי השמה

= שומר ערך. לכל אופרטור חשבון ומחרוזת יש צורה משולבת שמעדכנת משתנה במקום.

<?php
$total = 100;
$total += 20;   // $total = $total + 20
$total -= 5;
$total *= 2;
$total /= 10;
$total **= 2;
echo $total, "\n";

$path = "/home";
$path .= "/docs";      // append a string
echo $path, "\n";

$name = null;
$name ??= "Guest";     // assign only if null or unset
echo $name, "\n";

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

הגדלה והקטנה: ++ ו---

$i++ מחזיר את הערך הנוכחי, ואז מוסיף 1. ++$i מוסיף 1, ואז מחזיר את הערך החדש. ההבדל נראה רק כשמשתמשים בתוצאה באותו ביטוי.

<?php
$i = 5;
echo $i++, "\n";  // prints 5, then $i becomes 6
echo $i, "\n";

$j = 5;
echo ++$j, "\n";  // $j becomes 6, prints 6

$k = 10;
$k--;
echo $k, "\n";

// ++ also works on letters
$col = "A";
$col++;
echo $col, "\n";
$col = "Z";
$col++;
echo $col, "\n";

טריק האותיות הוא הדרך שבה נוצרים לעיתים קרובות שמות עמודות בגיליון אלקטרוני (A, B, ... Z, AA).

אופרטורים לוגיים: &&, ||, ! ו-xor

&& ו-|| מקצרים: הצד הימני לא מחושב כשהצד השמאלי כבר מכריע את התוצאה. זה מה שהופך את isset($user) && $user->isAdmin() לבטוח.

<?php
$age = 20;
$hasTicket = true;

var_dump($age >= 18 && $hasTicket);
var_dump($age < 12 || $age > 65);
var_dump(!$hasTicket);
var_dump(true xor true);

function check(string $label): bool {
    echo "checked $label\n";
    return true;
}
false && check("A");   // never runs
true || check("B");    // never runs
true && check("C");    // runs

and מול &&: מלכודת הקדימות

and ו-or קושרים חלש יותר מ-=, כך שבהשמה הם פועלים אחרי שהערך כבר נשמר. זה באג קלאסי:

<?php
$x = true and false;   // read as: ($x = true) and false
var_dump($x);

$y = true && false;    // read as: $y = (true && false)
var_dump($y);

$z = (true and false); // parentheses fix it
var_dump($z);

הקדימות הנמוכה שימושית בניב אחד, $file = fopen($path, 'r') or die('Cannot open');, שבו רוצים שההשמה תקרה קודם. בכל מקום אחר, השתמשו ב-&& וב-||.

אופרטורי מחרוזות: . ו-.=

ל-PHP יש שני אופרטורי מחרוזות: . משרשר שתי מחרוזות ("Grace" . " " . "Hopper") ו-.= מוסיף למשתנה ($html .= "<li>"). + אף פעם לא משרשר מחרוזות: "3" + "4" הוא המספר 7, בעוד "3" . "4" הוא המחרוזת "34". עמוד המחרוזות מסביר אינטרפולציה ומירכאות.

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

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

<?php
var_dump(1 <=> 2);
var_dump(2 <=> 2);
var_dump(3 <=> 2);

$prices = [30, 5, 120, 18];
usort($prices, fn($a, $b) => $a <=> $b);
echo implode(", ", $prices), "\n";

usort($prices, fn($a, $b) => $b <=> $a);   // descending
echo implode(", ", $prices), "\n";

אופרטורי מערכים

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

<?php
print_r([1, 2] + [3, 4, 5]);
print_r(["a" => 1] + ["a" => 99, "b" => 2]);

var_dump(["a" => 1, "b" => 2] == ["b" => 2, "a" => 1]);
var_dump(["a" => 1, "b" => 2] === ["b" => 2, "a" => 1]);

כדי להוסיף רשימה אחת לסוף אחרת, השתמשו ב-array_merge() או בתחביר הפיזור [...$a, ...$b].

קדימות אופרטורים

כשביטוי מערבב אופרטורים, PHP מפעילה אותם בסדר קבוע. אלה שמכשילים אנשים, עם מה ש-PHP 8.3 מדפיסה:

echo 2 + 3 * 4;        // 14: * before +
echo (2 + 3) * 4;      // 20
echo 2 ** 3 ** 2;      // 512: right to left, 2 ** 9
echo -2 ** 2;          // -4: ** before unary minus
echo "Sum: " . 2 + 3;  // Sum: 5, since PHP 8 + runs before .

כשיש ספק, הוסיפו סוגריים. הם לא עולים כלום, ומי שיקרא את השורה הבאה לא יצטרך לזכור את הטבלה.