PHP round(), floor() e ceil(): arredondar e matemática

round($x) arredonda para o inteiro mais próximo, floor($x) sempre arredonda para baixo e ceil($x) sempre arredonda para cima. Passe um segundo argumento ao round() para as casas decimais: 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

As três retornam float, mesmo quando o valor é inteiro. var_dump(round(5)) imprime float(5), então faça um cast com (int) quando precisar de um inteiro.

Arredondar para 2 casas decimais

O segundo argumento do round() é a precisão. Um número positivo arredonda para essa quantidade de casas decimais. Um número negativo arredonda à esquerda do ponto decimal, o que é prático para números aproximados como "cerca de 1.200 visitantes".

<?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) imprime 3.1 porque um float não sabe quantos zeros você queria. Quando o número vai para uma página (preços, porcentagens), formate-o: number_format() transforma 3.1 em "3.10" com number_format(3.1, 2), e sprintf('%.2f', $x) faz o mesmo.

Arredondar a metade para cima, para baixo ou para o par

Por padrão, o round() arredonda a metade para longe do zero, que é o arredondamento que a maioria aprendeu na escola. O terceiro argumento escolhe outra regra para valores exatamente no meio entre dois números.

<?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 é o "arredondamento bancário": as metades vão para o número par mais próximo, então arredondar muitos valores não gera um desvio para cima com o tempo. Código de contabilidade costuma querer isso.

floor e ceil com números negativos

floor() vai em direção a menos infinito e ceil() em direção a mais infinito. Com números negativos isso surpreende: floor(-3.5) é -4, não -3. Se você quer cortar as casas decimais (truncar em direção ao zero), faça um cast para 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";

A linha da paginação é o uso clássico do ceil(): qualquer item que sobrar ainda precisa de uma página.

Divisão inteira e módulo

/ retorna float quando a divisão não é exata, então 7 / 2 é 3.5. Para divisão inteira use intdiv(), que descarta o resto, e % para o próprio resto.

<?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 os dois operandos em inteiros primeiro, então 7.5 % 2 é 1, e desde o PHP 8.1 também imprime Deprecated: Implicit conversion from float 7.5 to int loses precision. Use fmod() quando as casas decimais importarem. Dividir por zero com /, intdiv() ou % lança um DivisionByZeroError no PHP 8, então verifique o divisor antes quando ele vier da entrada.

Potências, raízes, abs, max e min

** eleva a uma potência (pow() faz o mesmo), sqrt() calcula a raiz quadrada e abs() remove o sinal. max() e min() recebem vários argumentos ou um 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";

** é avaliado da direita para a esquerda, então 2 ** 3 ** 2 significa 2 ** 9. O par max(0, min(100, $x)) é o jeito comum de limitar um valor entre um mínimo e um máximo. M_PI guarda o valor de pi se você precisar para círculos.

Números aleatórios com random_int e rand

random_int($min, $max) retorna um inteiro aleatório com as duas pontas incluídas. A saída muda a cada execução, então clique em Run algumas vezes.

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

Use random_int() para tudo que envolve segurança: códigos de login, tokens, links de redefinição de senha. rand() e mt_rand() continuam funcionando e aceitam os mesmos argumentos ($min, $max), mas a sequência delas pode ser prevista. Para embaralhar e sortear com uma fonte segura, o PHP 8.2 adicionou Random\Randomizer ($r->getInt(1, 6), $r->shuffleArray($a)).

Por que floor() às vezes dá a resposta errada

Floats são guardados em binário, e muitos valores decimais (como 0.1) não podem ser guardados com exatidão. Na maior parte do tempo a impressão esconde isso, mas floor() e (int) não arredondam, eles cortam, e um valor como 7.999999999 vira 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 você precisa de decimais exatos, como com dinheiro, guarde unidades inteiras (centavos como inteiros: 1999 em vez de 19.99) e divida só na hora de exibir. Arredondar para uma precisão razoável antes do floor() ou do ceil(), como na última linha, também resolve a maioria dos casos.