round(), floor() ו-ceil() ב-PHP: עיגול ומתמטיקה

round($x) מעגלת למספר השלם הקרוב, floor($x) תמיד מעגלת למטה ו-ceil($x) תמיד מעגלת למעלה. תנו ל-round() ארגומנט שני עבור ספרות אחרי הנקודה: round(3.14159, 2) הוא 3.14.

<?php
$price = 19.456;

echo round($price), "\n";     // nearest whole number
echo round($price, 2), "\n";  // 2 decimal places
echo floor($price), "\n";     // always down
echo ceil($price), "\n";      // always up

שלושתן מחזירות float, גם כשהערך שלם. var_dump(round(5)) מדפיסה float(5), אז המירו עם (int) כשאתם צריכים מספר שלם.

עיגול לשתי ספרות אחרי הנקודה

הארגומנט השני של round() הוא הדיוק. מספר חיובי מעגל לכמות כזו של ספרות אחרי הנקודה. מספר שלילי מעגל משמאל לנקודה העשרונית, וזה שימושי למספרים משוערים כמו "בערך 1,200 מבקרים".

<?php
$n = 1234.5678;

echo round($n, 2), "\n";   // 2 decimals
echo round($n, 1), "\n";   // 1 decimal
echo round($n, -1), "\n";  // nearest ten
echo round($n, -2), "\n";  // nearest hundred

echo round(2.5), " ", round(-2.5), "\n";  // halves go away from zero
echo round(3.10, 2), "\n";                // trailing zero is not kept

round(3.10, 2) מדפיסה 3.1 כי ל-float אין מושג כמה אפסים רציתם. כשהמספר מוצג בדף (מחירים, אחוזים), עצבו אותו במקום זאת: number_format() הופכת את 3.1 ל-"3.10" עם number_format(3.1, 2), ו-sprintf('%.2f', $x) עושה את אותו הדבר.

עיגול חצי למעלה, חצי למטה או חצי לזוגי

כברירת מחדל round() מעגלת חצי הרחק מאפס, וזה העיגול שרוב האנשים למדו בבית הספר. הארגומנט השלישי בוחר כלל אחר לערכים שנמצאים בדיוק באמצע בין שני מספרים.

<?php
$values = [1.5, 2.5, -2.5];

foreach ($values as $v) {
    echo $v, ": ",
        round($v, 0, PHP_ROUND_HALF_UP), " up, ",
        round($v, 0, PHP_ROUND_HALF_DOWN), " down, ",
        round($v, 0, PHP_ROUND_HALF_EVEN), " even, ",
        round($v, 0, PHP_ROUND_HALF_ODD), " odd\n";
}

PHP_ROUND_HALF_EVEN הוא "עיגול בנקאי": חצאים הולכים למספר הזוגי הקרוב, כך שעיגול של הרבה ערכים לא נסחף כלפי מעלה עם הזמן. קוד הנהלת חשבונות רוצה אותו לעיתים קרובות.

floor ו-ceil עם מספרים שליליים

floor() נעה לכיוון מינוס אינסוף ו-ceil() לכיוון פלוס אינסוף. עם מספרים שליליים זה מפתיע: floor(-3.5) הוא -4, לא -3. אם אתם רוצים לחתוך את הספרות אחרי הנקודה (לכיוון אפס), המירו ל-int במקום זאת.

<?php
foreach ([3.7, -3.7] as $x) {
    echo "x = $x\n";
    echo "  floor: ", floor($x), "\n";
    echo "  ceil:  ", ceil($x), "\n";
    echo "  (int): ", (int) $x, "\n";
}

// Pages needed for 23 items at 10 per page
echo ceil(23 / 10), " pages\n";

שורת הדפדוף היא השימוש הקלאסי ב-ceil(): כל פריט שנשאר עדיין צריך דף.

חילוק שלמים ומודולו

/ מחזיר float כשהחילוק לא מתחלק בדיוק, ולכן 7 / 2 הוא 3.5. לחילוק במספרים שלמים השתמשו ב-intdiv(), שמשמיטה את השארית, וב-% לשארית עצמה.

<?php
$minutes = 135;

$hours = intdiv($minutes, 60);
$rest = $minutes % 60;
echo "$minutes minutes = {$hours}h {$rest}m\n";

echo 7 / 2, "\n";
echo intdiv(-7, 2), "\n";   // truncates toward zero
echo -7 % 3, "\n";          // sign of the left operand
echo fmod(7.5, 2), "\n";    // remainder for floats

// Even or odd
foreach ([4, 7] as $n) {
    echo $n, $n % 2 === 0 ? " is even\n" : " is odd\n";
}

% ממיר קודם את שני האופרנדים למספרים שלמים, ולכן 7.5 % 2 הוא 1, ומאז PHP 8.1 הוא גם מדפיס Deprecated: Implicit conversion from float 7.5 to int loses precision. השתמשו ב-fmod() כשהספרות אחרי הנקודה חשובות. חילוק באפס עם /, intdiv() או % זורק DivisionByZeroError ב-PHP 8, אז בדקו את המחלק קודם כשהוא מגיע מקלט.

חזקות, שורשים, abs, max ו-min

** מעלה בחזקה (pow() עושה אותו דבר), sqrt() מוציאה שורש ריבועי ו-abs() מסירה את הסימן. max() ו-min() מקבלות כמה ארגומנטים או מערך אחד.

<?php
echo 2 ** 10, "\n";       // 1024
echo 2 ** -1, "\n";       // 0.5
echo sqrt(144), "\n";     // 12
echo 27 ** (1 / 3), "\n"; // cube root
echo abs(-42), "\n";      // 42

$scores = [72, 95, 88, 61];
echo max($scores), " ", min($scores), "\n";
echo max(3, 9, 4), "\n";
echo array_sum($scores) / count($scores), "\n"; // average

// Clamp a value into the range 0 to 100
$volume = 140;
echo max(0, min(100, $volume)), "\n";

** מחושב מימין לשמאל, ולכן 2 ** 3 ** 2 פירושו 2 ** 9. הצמד max(0, min(100, $x)) הוא הדרך הרגילה להגביל ערך בין גבול תחתון לגבול עליון. M_PI מחזיק את פאי אם אתם צריכים אותו למעגלים.

מספרים אקראיים עם random_int ו-rand

random_int($min, $max) מחזירה מספר שלם אקראי כששני הקצוות כלולים. הפלט משתנה בכל הרצה, אז לחצו על Run כמה פעמים.

<?php
echo "Dice: ", random_int(1, 6), "\n";

// A 6-digit code, zero padded
printf("Code: %06d\n", random_int(0, 999999));

// Random element of an array
$colors = ['red', 'green', 'blue'];
echo "Color: ", $colors[array_rand($colors)], "\n";

// Random float between 0 and 1
echo "Float: ", random_int(0, PHP_INT_MAX) / PHP_INT_MAX, "\n";

השתמשו ב-random_int() לכל דבר שקשור לאבטחה: קודי התחברות, טוקנים, קישורים לאיפוס סיסמה. rand() ו-mt_rand() עדיין עובדות ומקבלות את אותם ארגומנטים ($min, $max), אבל אפשר לחזות את הרצף שלהן. לערבוב ולבחירה עם מקור מאובטח, PHP 8.2 הוסיפה את Random\Randomizer ($r->getInt(1, 6), $r->shuffleArray($a)).

למה floor() נותנת לפעמים תשובה שגויה

floats נשמרים בבינארי, והרבה ערכים עשרוניים (כמו 0.1) לא ניתנים לשמירה מדויקת. רוב הזמן ההדפסה מסתירה את זה, אבל floor() ו-(int) לא מעגלות, הן חותכות, וערך כמו 7.999999999 הופך ל-7.

<?php
$x = (0.1 + 0.7) * 10;

echo $x, "\n";            // looks like 8
var_dump($x);             // the real value
echo floor($x), "\n";     // 7, not 8
echo floor(round($x, 10)), "\n"; // round first, then floor

כשאתם צריכים ספרות עשרוניות מדויקות, כמו בכסף, שמרו יחידות שלמות (סנטים כמספרים שלמים: 1999 במקום 19.99) וחלקו רק לצורך הצגה. עיגול לדיוק הגיוני לפני floor() או ceil(), כמו בשורה האחרונה, פותר גם את רוב המקרים.