round

(PHP 4, PHP 5, PHP 7, PHP 8)

round — Redondea un número de punto flotante

Descripción

round(int|float $num, int $precision = 0, int|RoundingMode $mode = RoundingMode::HalfAwayFromZero): float

Devuelve el valor redondeado de num a la precisión precision (número de dígitos después del punto decimal). El argumento precision puede ser negativo o null : es su valor por omisión.

Parámetros

num

El valor a redondear.

precision

El número opcional de decimales a redondear.

Si el argumento precision es positivo, num será redondeado utilizando el argumento precision para definir el número significativo de dígitos después del punto decimal.

Si el argumento precision es negativo, num será redondeado utilizando el argumento precision para definir el número significativo de dígitos antes del punto decimal, i.e. el múltiplo más cercano de pow(10, -$precision), i.e. para una precision de -1, num será redondeado a 10, para una precision de -2 a 100, etc.

mode

Utilice RoundingMode o una de las constantes siguientes para especificar el método de redondeo.

Constantes	Descripción
`PHP_ROUND_HALF_UP`	Redondea `num` alejándose de cero cuando está a mitad de camino, redondeando así 1.5 a 2, y -1.5 a -2.
`PHP_ROUND_HALF_DOWN`	Redondea `num` acercándose a cero cuando está a mitad de camino, redondeando así 1.5 a 1, y -1.5 a -1.
`PHP_ROUND_HALF_EVEN`	Redondea `num` al valor par más cercano cuando está a mitad de camino, redondeando así 1.5 y 2.5 a 2.
`PHP_ROUND_HALF_ODD`	Redondea `num` al valor impar más cercano cuando está a mitad de camino, redondeando así 1.5 a 1 y 2.5 a 3.

Sin embargo, tenga en cuenta que algunos métodos recién añadidos solo existen en RoundingMode.

Valores devueltos

El valor redondeado a la precision dada como número decimal.

Errores/Excepciones

La función lanza una ValueError si mode es inválido. Anterior a PHP 8.4.0, un modo inválido era silenciosamente convertido en PHP_ROUND_HALF_UP.

Historial de cambios

Versión	Descripción
8.4.0	Cuatro nuevos métodos de redondeo han sido añadidos.
8.4.0	Ahora lanza una ValueError si `mode` es inválido.
8.0.0	`num` ya no acepta objetos internos que soporten las conversiones numéricas.

Ejemplos

Ejemplo #1 Ejemplo con round()

<?php
var_dump(round(3.4));
var_dump(round(3.5));
var_dump(round(3.6));
var_dump(round(3.6, 0));
var_dump(round(5.045, 2));
var_dump(round(5.055, 2));
var_dump(round(345, -2));
var_dump(round(345, -3));
var_dump(round(678, -2));
var_dump(round(678, -3));
?>

El ejemplo anterior mostrará :

float(3)
float(4)
float(4)
float(4)
float(5.05)
float(5.06)
float(300)
float(0)
float(700)
float(1000)

Ejemplo #2 Cómo precision afecta un flotante

<?php
$number = 135.79;

var_dump(round($number, 3));
var_dump(round($number, 2));
var_dump(round($number, 1));
var_dump(round($number, 0));
var_dump(round($number, -1));
var_dump(round($number, -2));
var_dump(round($number, -3));
?>

El ejemplo anterior mostrará :

float(135.79)
float(135.79)
float(135.8)
float(136)
float(140)
float(100)
float(0)

Ejemplo #3 Ejemplo con mode

<?php
echo "Método de redondeo con 9.5" . PHP_EOL;
var_dump(round(9.5, 0, PHP_ROUND_HALF_UP));
var_dump(round(9.5, 0, PHP_ROUND_HALF_DOWN));
var_dump(round(9.5, 0, PHP_ROUND_HALF_EVEN));
var_dump(round(9.5, 0, PHP_ROUND_HALF_ODD));

echo PHP_EOL;
echo "Método de redondeo con 8.5" . PHP_EOL;
var_dump(round(8.5, 0, PHP_ROUND_HALF_UP));
var_dump(round(8.5, 0, PHP_ROUND_HALF_DOWN));
var_dump(round(8.5, 0, PHP_ROUND_HALF_EVEN));
var_dump(round(8.5, 0, PHP_ROUND_HALF_ODD));
?>

El ejemplo anterior mostrará :

Método de redondeo con 9.5
float(10)
float(9)
float(10)
float(9)

Método de redondeo con 8.5
float(9)
float(8)
float(8)
float(9)

Ejemplo #4 Ejemplo con mode y precision

<?php
echo "Uso de PHP_ROUND_HALF_UP con una precisión de una decimal" . PHP_EOL;
var_dump(round( 1.55, 1, PHP_ROUND_HALF_UP));
var_dump(round(-1.55, 1, PHP_ROUND_HALF_UP));

echo PHP_EOL;
echo "Uso de PHP_ROUND_HALF_DOWN con una precisión de una decimal" . PHP_EOL;
var_dump(round( 1.55, 1, PHP_ROUND_HALF_DOWN));
var_dump(round(-1.55, 1, PHP_ROUND_HALF_DOWN));

echo PHP_EOL;
echo "Uso de PHP_ROUND_HALF_EVEN con una precisión de una decimal" . PHP_EOL;
var_dump(round( 1.55, 1, PHP_ROUND_HALF_EVEN));
var_dump(round(-1.55, 1, PHP_ROUND_HALF_EVEN));

echo PHP_EOL;
echo "Uso de PHP_ROUND_HALF_ODD con una precisión de una decimal" . PHP_EOL;
var_dump(round( 1.55, 1, PHP_ROUND_HALF_ODD));
var_dump(round(-1.55, 1, PHP_ROUND_HALF_ODD));
?>

El ejemplo anterior mostrará :

Uso de PHP_ROUND_HALF_UP con una precisión de una decimal
float(1.6)
float(-1.6)

Uso de PHP_ROUND_HALF_DOWN con una precisión de una decimal
float(1.5)
float(-1.5)

Uso de PHP_ROUND_HALF_EVEN con una precisión de una decimal
float(1.6)
float(-1.6)

Uso de PHP_ROUND_HALF_ODD con una precisión de una decimal
float(1.5)
float(-1.5)

Ejemplo #5 Ejemplo de uso de RoundingMode

<?php
foreach (RoundingMode::cases() as $mode) {
    foreach ([
        8.5,
        9.5,
        -3.5,
    ] as $number) {
        printf("%-17s: %+.17g -> %+.17g\n", $mode->name, $number, round($number, 0, $mode));
    }
    echo "\n";
}
?>

El ejemplo anterior mostrará :

HalfAwayFromZero : +8.5 -> +9
HalfAwayFromZero : +9.5 -> +10
HalfAwayFromZero : -3.5 -> -4

HalfTowardsZero  : +8.5 -> +8
HalfTowardsZero  : +9.5 -> +9
HalfTowardsZero  : -3.5 -> -3

HalfEven         : +8.5 -> +8
HalfEven         : +9.5 -> +10
HalfEven         : -3.5 -> -4

HalfOdd          : +8.5 -> +9
HalfOdd          : +9.5 -> +9
HalfOdd          : -3.5 -> -3

TowardsZero      : +8.5 -> +8
TowardsZero      : +9.5 -> +9
TowardsZero      : -3.5 -> -3

AwayFromZero     : +8.5 -> +9
AwayFromZero     : +9.5 -> +10
AwayFromZero     : -3.5 -> -4

NegativeInfinity : +8.5 -> +8
NegativeInfinity : +9.5 -> +9
NegativeInfinity : -3.5 -> -4

PositiveInfinity : +8.5 -> +9
PositiveInfinity : +9.5 -> +10
PositiveInfinity : -3.5 -> -3

Ver también

ceil() - Redondea al número superior
floor() - Redondea hacia el entero inferior
number_format() - Formatea un número para su visualización

Found A Problem?

Learn How To Improve This Page • Submit a Pull Request • Report a Bug

User Contributed Notes 13 notes

up

down

327

takingsides at gmail dot com ¶

11 years ago

In my opinion this function lacks two flags:

- PHP_ROUND_UP - Always round up.
- PHP_ROUND_DOWN - Always round down.

In accounting, it's often necessary to always round up, or down to a precision of thousandths.

<?php
function round_up($number, $precision = 2)
{
    $fig = (int) str_pad('1', $precision, '0');
    return (ceil($number * $fig) / $fig);
}

function round_down($number, $precision = 2)
{
    $fig = (int) str_pad('1', $precision, '0');
    return (floor($number * $fig) / $fig);
}
?>

up

down

33

depaula at unilogica dot com ¶

8 years ago

As PHP doesn't have a a native number truncate function, this is my solution - a function that can be usefull if you need truncate instead round a number.

<?php
/**
 * Truncate a float number, example: <code>truncate(-1.49999, 2); // returns -1.49
 * truncate(.49999, 3); // returns 0.499
 * </code>
 * @param float $val Float number to be truncate
 * @param int f Number of precision
 * @return float
 */
function truncate($val, $f="0")
{
    if(($p = strpos($val, '.')) !== false) {
        $val = floatval(substr($val, 0, $p + 1 + $f));
    }
    return $val;
}
?>

Originally posted in http://stackoverflow.com/a/12710283/1596489

up

down

31

slimusgm at gmail dot com ¶

10 years ago

If you have negative zero and you need return positive number simple add +0:

$number = -2.38419e-07;
var_dump(round($number,1));//float(-0)
var_dump(round($number,1) + 0);//float(0)

up

down

20

esion99 at gmail dot com ¶

11 years ago

Unexpected result or misunderstanding (php v5.5.9)

<?php

echo round(1.55, 1, PHP_ROUND_HALF_DOWN); // 1.5
echo round(1.551, 1, PHP_ROUND_HALF_DOWN); //1.6

?>

up

down

21

djcox99 at googlemail dot com ¶

11 years ago

I discovered that under some conditions you can get rounding errors with round when converting the number to a string afterwards.

To fix this I swapped round() for number_format().

Unfortunately i cant give an example (because the number cant be represented as a string !)

essentially I had round(0.688888889,2);

which would stay as 0.68888889 when printed as a string.

But using number_format it correctly became 0.69.

up

down

10

craft at ckdevelop dot org ¶

11 years ago

function mround($val, $f=2, $d=6){
    return sprintf("%".$d.".".$f."f", $val);
}

echo mround(34.89999);  //34.90

up

down

17

Anonymous ¶

14 years ago

Here is function that rounds to a specified increment, but always up. I had to use it for price adjustment that always went up to $5 increments.



<?php  

function roundUpTo($number, $increments) {

    $increments = 1 / $increments;

    return (ceil($number * $increments) / $increments);

}

?>

up

down

18

twan at ecreation dot nl ¶

25 years ago

If you'd only want to round for displaying variables (not for calculating on the rounded result) then you should use printf with the float:



<?php printf ("%6.2f",3.39532); ?>



This returns: 3.40 .

up

down

8

christian at deligant dot net ¶

13 years ago

this function (as all mathematical operators) takes care of the setlocale setting, resulting in some weirdness when using the result where the english math notation is expected, as the printout of the result in a width: style attribute!



<?php

$a=3/4;

echo round($a, 2); // 0.75



setlocale(LC_ALL, 'it_IT@euro', 'it_IT', 'it');

$b=3/4;

echo round($b,2); // 0,75

?>

up

down

7

michaeldnelson dot mdn at gmail dot com ¶

15 years ago

This function will let you round to an arbitrary non-zero number.  Zero of course causes a division by zero.



<?php

function roundTo($number, $to){

    return round($number/$to, 0)* $to;

}



echo roundTo(87.23, 20); //80

echo roundTo(-87.23, 20); //-80

echo roundTo(87.23, .25); //87.25

echo roundTo(.23, .25); //.25

?>

up

down

3

greghenle at gmail dot com ¶

8 years ago

/**
 * Round to first significant digit
 * +N to +infinity
 * -N to -infinity
 *
 */
function round1stSignificant ( $N ) {
  if ( $N === 0 ) {
    return 0;
  }

  $x = floor ( log10 ( abs( $N ) ) );

  return ( $N > 0 )
    ? ceil( $N * pow ( 10, $x * -1 ) ) * pow( 10, $x )
    : floor( $N * pow ( 10, $x * -1 ) ) * pow( 10, $x );
}

echo round1stSignificant( 39144818 ) . PHP_EOL;
echo round1stSignificant( 124818 ) . PHP_EOL;
echo round1stSignificant( 0.07468 ) . PHP_EOL;
echo round1stSignificant( 0 ) . PHP_EOL;
echo round1stSignificant( -0.07468 ) . PHP_EOL;

/**
 * Output
 * 
 * 40000000
 * 200000
 * 0.08
 * 0
 * -0.08
 * 
 */

up

down

4

dastra ¶

13 years ago

round() will sometimes return E notation when rounding a float when the amount is small enough - see  https://bugs.php.net/bug.php?id=44223 .  Apparently it's a feature.

To work around this "feature" when converting to a string, surround your round statement with an sprintf:

sprintf("%.10f", round( $amountToBeRounded, 10));

up

down

9

php at silisoftware dot com ¶

22 years ago

Here's a function to round to an arbitary number of significant digits. Don't confuse it with rounding to a negative precision - that counts back from the decimal point, this function counts forward from the Most Significant Digit.



ex:



<?php

round(1241757, -3); // 1242000

RoundSigDigs(1241757, 3); // 1240000

?>



Works on negative numbers too. $sigdigs should be >= 0



<?php

function RoundSigDigs($number, $sigdigs) {

    $multiplier = 1;

    while ($number < 0.1) {

        $number *= 10;

        $multiplier /= 10;

    }

    while ($number >= 1) {

        $number /= 10;

        $multiplier *= 10;

    }

    return round($number, $sigdigs) * $multiplier;

}

?>