טיפוסי נתונים ב-PHP: int, float, string, bool, array, null

ב-PHP יש שמונה טיפוסים שמשתמשים בהם כל יום: int, float, string, bool, array, object, null, ועוד callable לפונקציות שמעבירים הלאה. למשתנה אין טיפוס קבוע; לערך הנוכחי שלו יש. var_dump($x) מציגה גם את הטיפוס וגם את הערך, ו-gettype($x) מחזירה את הטיפוס כמחרוזת.

<?php
$values = [42, 3.14, "hello", true, [1, 2, 3], null, new stdClass()];

printf("%-8s %-10s %s\n", "gettype", "debug", "value");
foreach ($values as $value) {
    printf("%-8s %-10s %s\n", gettype($value), get_debug_type($value), json_encode($value));
}

העמודה הראשונה היא gettype(), והשנייה get_debug_type(). החליפו ערך בערך משלכם והריצו שוב. הן חלוקות על כמה שמות: gettype אומרת integer, double ו-boolean מסיבות היסטוריות, בעוד get_debug_type משתמשת בשמות מהצהרות הטיפוס (int, float, bool) ונותנת את שם המחלקה עבור אובייקט.

טיפוסי PHP במבט אחד

בדיקת ערכים עם var_dump

var_dump היא הכלי לראות מה באמת יש לכם. היא מדפיסה את הטיפוס, את הערך, ועבור מחרוזות את האורך בבתים:

<?php
var_dump(10);
var_dump(10.0);
var_dump("10");
var_dump(true);
var_dump(null);
var_dump(["id" => 7, "tags" => ["php", "web"]]);
var_dump("café");   // 5 bytes: é takes two bytes in UTF-8

echo הייתה מדפיסה 10 עבור שלושת הראשונים ומסתירה את ההבדל. האורך ב-string(5) "café" סופר בתים, ולכן strlen ו-mb_strlen נותנות תוצאות שונות לטקסט שאינו ASCII.

מספרים שלמים ו-floats

מספר שלם הוא מספר ללא שבר. בליטרלים אפשר להשתמש בקווים תחתונים לקריאוּת, ובכתיב הקסדצימלי, אוקטלי ובינארי. float הוא כל מספר עם נקודה עשרונית או מעריך, וכמו בכל שפה הוא שומר את רוב השברים העשרוניים בקירוב:

<?php
$population = 8_100_000_000;   // underscores are ignored
var_dump($population);
var_dump(0xFF, 0b1010, 0o17);  // hex, binary, octal
var_dump(PHP_INT_MAX);
var_dump(PHP_INT_MAX + 1);     // too big: becomes a float

var_dump(7 / 2);               // / returns a float when needed
var_dump(8 / 2);               // and an int when the result is whole
var_dump(intdiv(7, 2));        // integer division

var_dump(0.1 + 0.2);
var_dump(0.1 + 0.2 == 0.3);
var_dump(abs((0.1 + 0.2) - 0.3) < PHP_FLOAT_EPSILON);

לעולם אל תשוו floats עם ==; השוו את ההפרש לסובלנות קטנה, או עגלו קודם את שני הצדדים. לכסף, שמרו אגורות שלמות כמספרים שלמים.

בוליאנים ואילו ערכים הם false

bool הוא true או false. במקומות ש-PHP מצפה לתנאי (if, while, !), כל ערך מומר ל-bool, ורשימה קצרה של ערכים נחשבת false: false, 0, 0.0, "", "0", [] ו-null. כל השאר true. הטבלה מציגה כל ערך עם הטיפוס שלו, ההמרה שלו ל-bool והאם הוא מספרי:

ההפתעות הן "0.0", " " ו-"null": שלושתן מחרוזות לא ריקות שאינן "0", ולכן הן true, ו-if ($value) מריצה את הגוף שלה עבורן.

מערכים, אובייקטים ו-null

מערך מחזיק כל תערובת של ערכים תחת מפתחות שלמים או מחרוזות. אובייקט הוא מופע של מחלקה; stdClass היא המחלקה הריקה של PHP לאובייקטים מהירים, ו-(object) הופכת מערך לאובייקט כזה. null פירושו "אין ערך":

<?php
$user = ["name" => "Ada", "roles" => ["admin", "editor"]];
echo gettype($user), ": ", $user["name"], "\n";

$point = new stdClass();
$point->x = 3;
$point->y = 4;
echo get_debug_type($point), ": ", $point->x, ",", $point->y, "\n";

$config = (object) ["debug" => true];
echo get_debug_type($config), ": debug is ", var_export($config->debug, true), "\n";

class Product
{
    public function __construct(public string $name, public float $price) {}
}
$p = new Product("Lamp", 25.0);
echo get_debug_type($p), ": {$p->name}\n";

$nothing = null;
var_dump($nothing, is_null($nothing));

בדיקת טיפוס עם פונקציות is_*

לכל טיפוס יש פונקציית בדיקה שמחזירה true או false. is_numeric שונה מ-is_int: היא מקבלת גם מחרוזות מספריות, וזה מה שרוצים כשבודקים קלט מטופס.

<?php
$tests = [5, 5.0, "5", "5.5", " 5", "abc", true, null];

printf("%-7s %-6s %-8s %-9s %-10s\n", "value", "is_int", "is_float", "is_string", "is_numeric");
foreach ($tests as $t) {
    printf(
        "%-7s %-6s %-8s %-9s %-10s\n",
        var_export($t, true),
        is_int($t) ? "yes" : "",
        is_float($t) ? "yes" : "",
        is_string($t) ? "yes" : "",
        is_numeric($t) ? "yes" : ""
    );
}

אחרות: is_bool, is_array, is_object, is_null, is_callable, is_iterable, ו-$x instanceof ClassName למחלקה מסוימת.

המרות אוטומטיות וטיפוסים מחמירים

PHP ממירה טיפוסים אוטומטית כשאופרטור צריך טיפוס אחר. מחרוזת מספרית שמשמשת בחשבון הופכת למספר, ו-. הופכת מספרים למחרוזות. מחרוזת שאינה מספרית בכלל לא ניתנת לחיבור, ו-PHP 8 זורקת TypeError:

<?php
var_dump("10" + 5);        // int(15)
var_dump("1.5" * 2);       // float(3)
var_dump(10 . " items");   // string
var_dump("10" == "1e1");   // both numeric strings: compared as numbers
var_dump(100 == "1e2");

try {
    var_dump("abc" + 1);
} catch (TypeError $e) {
    echo "TypeError: ", $e->getMessage(), "\n";
}

גם פרמטרים עם טיפוס מומרים, אלא אם הקובץ מתחיל ב-declare(strict_types=1);. אז קריאה עם טיפוס סקלרי שגוי נכשלת במקום להיות מומרת:

<?php
declare(strict_types=1);

function addVat(float $net): float
{
    return $net * 1.2;
}

echo addVat(100), "\n";          // int to float is still allowed

try {
    echo addVat("100"), "\n";    // a string is not converted in strict mode
} catch (TypeError $e) {
    echo "TypeError: ", $e->getMessage(), "\n";
}

כדי להמיר בכוונה, השתמשו ב-cast: (int) "42", (float) "3.5", (string) 10, (bool) "0". עמוד המרת הטיפוסים מכסה כל cast ואת מקרי הקצה שלו.

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

כי == ממירה לפני ההשוואה, שני ערכים מטיפוסים שונים יכולים להיות "שווים" בדרכים שגורמות לבאגים, כמו "1e1" == "10" (שניהם המספר 10) או null == false. השתמשו ב-===, שדורשת גם אותו טיפוס, אלא אם אתם רוצים את ההמרה:

<?php
$pairs = [["1e1", "10"], [null, false], [0, ""], ["abc", 0], [1.0, 1]];

foreach ($pairs as [$a, $b]) {
    $show = var_export($a, true) . " vs " . var_export($b, true);
    printf("%-16s ==  %-6s ===  %s\n", $show, var_export($a == $b, true), var_export($a === $b, true));
}

PHP 8 תיקנה את המקרה הגרוע ביותר: "abc" == 0 היה פעם true ועכשיו הוא false, כי מחרוזת שאינה מספרית מושווית כמחרוזת. הטבלאות המלאות נמצאות בעמוד אופרטורי ההשוואה.