round

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

roundRedondea 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 float.

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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 resultado del ejemplo sería:

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() - Redondear fracciones hacia arriba
  • floor() - Redondear fracciones hacia abajo
  • number_format() - Formatear un número con los millares agrupados

add a note

User Contributed Notes 13 notes

up
324
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
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
30
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
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
18
esion99 at gmail dot com
10 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
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
19
twan at ecreation dot nl
24 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
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
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
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
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
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;
}
?>
up
3
dastra
12 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));
To Top