PHP round(), floor() e ceil(): arrotondare i numeri

round($x) arrotonda all'intero più vicino, floor($x) arrotonda sempre per difetto e ceil($x) sempre per eccesso. Passa a round() un secondo argomento per i decimali: round(3.14159, 2) vale 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

Tutte e tre restituiscono un float, anche quando il valore è intero. var_dump(round(5)) stampa float(5), quindi fai un cast con (int) quando ti serve un intero.

Arrotondare a 2 decimali

Il secondo argomento di round() è la precisione. Un numero positivo arrotonda a quel numero di decimali. Un numero negativo arrotonda a sinistra della virgola, comodo per cifre approssimative come "circa 1.200 visitatori".

<?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) stampa 3.1 perché un float non sa quanti zeri volevi. Quando il numero finisce su una pagina (prezzi, percentuali), formattalo: number_format() trasforma 3.1 in "3.10" con number_format(3.1, 2), e sprintf('%.2f', $x) fa lo stesso.

Arrotondare la metà per eccesso, per difetto o al pari

Di default round() arrotonda la metà allontanandosi dallo zero, cioè l'arrotondamento che quasi tutti hanno imparato a scuola. Il terzo argomento sceglie una regola diversa per i valori esattamente a metà tra due numeri.

<?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 è l'"arrotondamento bancario": le metà vanno al numero pari più vicino, così arrotondando molti valori il totale non deriva verso l'alto nel tempo. Il codice di contabilità spesso lo richiede.

floor e ceil con i numeri negativi

floor() si sposta verso meno infinito e ceil() verso più infinito. Con i numeri negativi questo sorprende: floor(-3.5) vale -4, non -3. Se vuoi tagliare i decimali (troncare verso lo zero), fai invece un cast a 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";

La riga della paginazione è l'uso classico di ceil(): anche un solo elemento avanzato ha bisogno di una pagina.

Divisione intera e modulo

/ restituisce un float quando la divisione non è esatta, quindi 7 / 2 vale 3.5. Per la divisione intera usa intdiv(), che scarta il resto, e % per il resto stesso.

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

% converte prima entrambi gli operandi in interi, quindi 7.5 % 2 vale 1, e da PHP 8.1 stampa anche Deprecated: Implicit conversion from float 7.5 to int loses precision. Usa fmod() quando i decimali contano. Dividere per zero con /, intdiv() o % lancia un DivisionByZeroError in PHP 8, quindi controlla prima il divisore quando arriva dall'input.

Potenze, radici, abs, max e min

** eleva a potenza (pow() fa lo stesso), sqrt() calcola la radice quadrata e abs() toglie il segno. max() e min() accettano più argomenti oppure un solo array.

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

** viene valutato da destra a sinistra, quindi 2 ** 3 ** 2 significa 2 ** 9. La coppia max(0, min(100, $x)) è il modo consueto per limitare un valore tra un minimo e un massimo. M_PI contiene pi greco se ti serve per i cerchi.

Numeri casuali con random_int e rand

random_int($min, $max) restituisce un intero casuale con entrambi gli estremi inclusi. L'output cambia a ogni esecuzione, quindi premi Run qualche volta.

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

Usa random_int() per tutto ciò che riguarda la sicurezza: codici di accesso, token, link per reimpostare la password. rand() e mt_rand() funzionano ancora e accettano gli stessi argomenti ($min, $max), ma la loro sequenza si può prevedere. Per mescolare e scegliere con una sorgente sicura, PHP 8.2 ha aggiunto Random\Randomizer ($r->getInt(1, 6), $r->shuffleArray($a)).

Perché a volte floor() dà il risultato sbagliato

I float sono memorizzati in binario e molti valori decimali (come 0.1) non si possono memorizzare in modo esatto. Quasi sempre la stampa lo nasconde, ma floor() e (int) non arrotondano, tagliano, e un valore come 7.999999999 diventa 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

Quando ti servono decimali esatti, come con il denaro, memorizza unità intere (centesimi come interi: 1999 invece di 19.99) e dividi solo per la visualizzazione. Anche arrotondare a una precisione ragionevole prima di floor() o ceil(), come nell'ultima riga, risolve la maggior parte dei casi.