PHP round(), floor() i ceil(): zaokrąglanie i matematyka

round($x) zaokrągla do najbliższej liczby całkowitej, floor($x) zawsze zaokrągla w dół, a ceil($x) zawsze w górę. Podaj round() drugi argument, aby określić miejsca po przecinku: round(3.14159, 2) daje 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

Wszystkie trzy zwracają float, nawet gdy wartość jest całkowita. var_dump(round(5)) wypisuje float(5), więc rzutuj przez (int), gdy potrzebujesz liczby całkowitej.

Zaokrąglanie do 2 miejsc po przecinku

Drugi argument round() to precyzja. Liczba dodatnia zaokrągla do tylu miejsc po przecinku. Liczba ujemna zaokrągla na lewo od przecinka, co przydaje się do przybliżonych liczb typu „około 1200 odwiedzających”.

<?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) wypisuje 3.1, bo float nie wie, ile zer chciałeś. Gdy liczba trafia na stronę (ceny, procenty), sformatuj ją: number_format() zamienia 3.1 w "3.10" przez number_format(3.1, 2), a sprintf('%.2f', $x) robi to samo.

Połówki w górę, w dół albo do parzystej

Domyślnie round() zaokrągla połówkę od zera, czyli tak, jak większość z nas uczyła się w szkole. Trzeci argument wybiera inną regułę dla wartości dokładnie w połowie między dwiema liczbami.

<?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 to „zaokrąglanie bankierskie”: połówki idą do najbliższej liczby parzystej, więc zaokrąglanie wielu wartości z czasem nie dryfuje w górę. Kod księgowy często tego potrzebuje.

floor i ceil z liczbami ujemnymi

floor() idzie w stronę minus nieskończoności, a ceil() w stronę plus nieskończoności. Przy liczbach ujemnych to zaskakuje: floor(-3.5) daje -4, a nie -3. Jeśli chcesz odciąć część ułamkową (obcięcie w stronę zera), rzutuj na 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";

Linia z paginacją to klasyczne użycie ceil(): każdy pozostały element nadal potrzebuje strony.

Dzielenie całkowite i modulo

/ zwraca float, gdy dzielenie nie jest bez reszty, więc 7 / 2 daje 3.5. Do dzielenia całkowitego użyj intdiv(), które odrzuca resztę, a do samej reszty %.

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

% najpierw konwertuje oba operandy na liczby całkowite, więc 7.5 % 2 daje 1, a od PHP 8.1 wypisuje też Deprecated: Implicit conversion from float 7.5 to int loses precision. Użyj fmod(), gdy część ułamkowa ma znaczenie. Dzielenie przez zero przez /, intdiv() albo % rzuca w PHP 8 DivisionByZeroError, więc sprawdź dzielnik, gdy pochodzi z danych wejściowych.

Potęgi, pierwiastki, abs, max i min

** podnosi do potęgi (pow() robi to samo), sqrt() liczy pierwiastek kwadratowy, a abs() usuwa znak. max() i min() przyjmują kilka argumentów albo jedną tablicę.

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

** jest obliczane od prawej do lewej, więc 2 ** 3 ** 2 oznacza 2 ** 9. Para max(0, min(100, $x)) to typowy sposób ograniczenia wartości między dolną a górną granicą. M_PI przechowuje liczbę pi, jeśli potrzebujesz jej do okręgów.

Liczby losowe przez random_int i rand

random_int($min, $max) zwraca losową liczbę całkowitą z oboma końcami włącznie. Wynik zmienia się przy każdym uruchomieniu, więc kliknij Run kilka razy.

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

Używaj random_int() do wszystkiego, co dotyczy bezpieczeństwa: kodów logowania, tokenów, linków do resetu hasła. rand() i mt_rand() nadal działają i przyjmują te same argumenty ($min, $max), ale ich sekwencję da się przewidzieć. Do tasowania i losowania z bezpiecznego źródła PHP 8.2 dodał Random\Randomizer ($r->getInt(1, 6), $r->shuffleArray($a)).

Dlaczego floor() czasem daje złą odpowiedź

Floaty są przechowywane binarnie, a wielu wartości dziesiętnych (jak 0.1) nie da się zapisać dokładnie. Zwykle wypisanie to ukrywa, ale floor() i (int) nie zaokrąglają, tylko obcinają, więc wartość w rodzaju 7.999999999 staje się 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

Gdy potrzebujesz dokładnych wartości dziesiętnych, jak przy pieniądzach, przechowuj całe jednostki (grosze jako liczby całkowite: 1999 zamiast 19.99) i dziel tylko do wyświetlenia. Zaokrąglenie do sensownej precyzji przed floor() albo ceil(), jak w ostatniej linii, też naprawia większość przypadków.