PHP round(), floor() y ceil(): redondear y matemáticas

round($x) redondea al entero más cercano, floor($x) siempre redondea hacia abajo y ceil($x) siempre hacia arriba. Dale a round() un segundo argumento para los decimales: round(3.14159, 2) es 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

Las tres devuelven un float, aunque el valor sea entero. var_dump(round(5)) imprime float(5), así que haz un cast con (int) cuando necesites un entero.

Redondear a 2 decimales

El segundo argumento de round() es la precisión. Un número positivo redondea a esa cantidad de decimales. Un número negativo redondea a la izquierda del punto decimal, algo útil para cifras aproximadas como "unos 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 un float no sabe cuántos ceros querías. Cuando el número va a mostrarse en una página (precios, porcentajes), dale formato: number_format() convierte 3.1 en "3.10" con number_format(3.1, 2), y sprintf('%.2f', $x) hace lo mismo.

Redondear la mitad hacia arriba, hacia abajo o al par

Por defecto, round() redondea la mitad alejándose de cero, que es el redondeo que casi todos aprendimos en el colegio. El tercer argumento elige otra regla para los valores que están justo a medio camino entre dos 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 es el "redondeo bancario": las mitades van al número par más cercano, así que redondear muchos valores no acumula un sesgo hacia arriba con el tiempo. El código de contabilidad suele necesitarlo.

floor y ceil con números negativos

floor() se mueve hacia menos infinito y ceil() hacia más infinito. Con números negativos eso sorprende: floor(-3.5) es -4, no -3. Si lo que quieres es quitar los decimales (truncar hacia cero), haz 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 línea de la paginación es el uso clásico de ceil(): cualquier elemento sobrante sigue necesitando una página.

División entera y módulo

/ devuelve un float cuando la división no es exacta, así que 7 / 2 es 3.5. Para la división entera usa intdiv(), que descarta el resto, y % para obtener el propio 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";
}

% convierte primero los dos operandos a enteros, así que 7.5 % 2 es 1, y desde PHP 8.1 además imprime Deprecated: Implicit conversion from float 7.5 to int loses precision. Usa fmod() cuando importen los decimales. Dividir por cero con /, intdiv() o % lanza un DivisionByZeroError en PHP 8, así que comprueba el divisor cuando venga de la entrada del usuario.

Potencias, raíces, abs, max y min

** eleva a una potencia (pow() hace lo mismo), sqrt() calcula una raíz cuadrada y abs() quita el signo. max() y min() aceptan varios argumentos o un único 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";

** se evalúa de derecha a izquierda, así que 2 ** 3 ** 2 significa 2 ** 9. La pareja max(0, min(100, $x)) es la forma habitual de limitar un valor entre un mínimo y un máximo. M_PI contiene pi por si lo necesitas para círculos.

Números aleatorios con random_int y rand

random_int($min, $max) devuelve un entero aleatorio con los dos extremos incluidos. La salida cambia en cada ejecución, así que pulsa Ejecutar varias veces.

<?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() para todo lo relacionado con la seguridad: códigos de inicio de sesión, tokens, enlaces para restablecer la contraseña. rand() y mt_rand() siguen funcionando y aceptan los mismos argumentos ($min, $max), pero su secuencia se puede predecir. Para barajar y elegir con una fuente segura, PHP 8.2 añadió Random\Randomizer ($r->getInt(1, 6), $r->shuffleArray($a)).

Por qué floor() a veces da una respuesta incorrecta

Los floats se guardan en binario, y muchos valores decimales (como 0.1) no se pueden guardar exactamente. Casi siempre la impresión lo disimula, pero floor() y (int) no redondean, cortan, y un valor como 7.999999999 se convierte en 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

Cuando necesites decimales exactos, como con el dinero, guarda unidades enteras (céntimos como integers: 1999 en lugar de 19.99) y divide solo para mostrar. Redondear a una precisión razonable antes de floor() o ceil(), como en la última línea, también arregla la mayoría de los casos.