round

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

round — Arrondit un nombre à virgule flottante

Description

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

Retourne la valeur arrondie de num à la précision precision (nombre de chiffres après la virgule). Le paramètre precision peut être négatif ou null : c'est sa valeur par défaut.

Liste de paramètres

num

La valeur à arrondir.

precision

Le nombre optionnel de décimales à arrondir.

Si le paramètre precision est positif, num sera arrondi en utilisant le paramètre precision pour définir le nombre significatif de chiffres après le point décimal.

Si le paramètre precision est négatif, num arrondi en utilisant le paramètre precision pour définir le nombre significatif de chiffres avant le point décimal, i.e. le multiple le plus proche de pow(10, -$precision), i.e. pour une precision de -1, num sera arrondi à 10, pour une precision de -2 à 100, etc.

mode

Utilisez une des constantes suivantes pour spécifier le mode d'arrondi.

Constantes	Description
`PHP_ROUND_HALF_UP`	Arrondit `num` en s'éloignant de zéro lorsqu'il est à mi-chemin, arrondissant ainsi 1.5 à 2, et -1.5 à -2.
`PHP_ROUND_HALF_DOWN`	Arrondit `num` en se rapprochant de zéro lorsqu'il est à mi-chemin, arrondissant ainsi 1.5 à 1, et -1.5 à -1.
`PHP_ROUND_HALF_EVEN`	Arrondit `num` à la valeur paire la plus proche lorsqu'il est à mi-chemin, arrondissant ainsi 1.5 et 2.5 à 2.
`PHP_ROUND_HALF_ODD`	Arrondit `num` à la valeur impaire la plus proche lorsqu'il est à mi-chemin, arrondissant ainsi 1.5 à 1 et 2.5 à 3.

Valeurs de retour

La valeur arrondie à la precision donnée en tant que nombre décimal.

Erreurs / Exceptions

La fonction lance une ValueError si mode est invalide. Antérieur à PHP 8.4.0, un mode invalide était silencieusement convertie en PHP_ROUND_HALF_UP.

Historique

Version	Description
8.4.0	Lance désormais une ValueError si `mode` est invalide.
8.0.0	`num` n'accepte plus les objets internes qui supporte les conversions numériques.

Exemples

Exemple #1 Exemple avec 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));
?>

L'exemple ci-dessus va afficher :

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

Exemple #2 Comment precision affecte un flottant

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

L'exemple ci-dessus va afficher :

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

Exemple #3 Exemple avec mode

<?php
echo "Mode d'arrondi avec 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 "Mode d'arrondi avec 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));
?>

L'exemple ci-dessus va afficher :

Mode d'arrondi avec 9.5
float(10)
float(9)
float(10)
float(9)

Mode d'arrondi avec 8.5
float(9)
float(8)
float(8)
float(9)

Exemple #4 Exemple avec mode et precision

<?php
echo "Utilisation de PHP_ROUND_HALF_UP avec une précision d'une décimale" . 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 "Utilisation de PHP_ROUND_HALF_DOWN avec une précision d'une décimale" . 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 "Utilisation de PHP_ROUND_HALF_EVEN avec une précision d'une décimale" . 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 "Utilisation de PHP_ROUND_HALF_ODD avec une précision d'une décimale" . PHP_EOL;
var_dump(round( 1.55, 1, PHP_ROUND_HALF_ODD));
var_dump(round(-1.55, 1, PHP_ROUND_HALF_ODD));
?>

L'exemple ci-dessus va afficher :

Utilisation de PHP_ROUND_HALF_UP avec une précision d'une décimale
float(1.6)
float(-1.6)

Utilisation de PHP_ROUND_HALF_DOWN avec une précision d'une décimale
float(1.5)
float(-1.5)

Utilisation de PHP_ROUND_HALF_EVEN avec une précision d'une décimale
float(1.6)
float(-1.6)

Utilisation de PHP_ROUND_HALF_ODD avec une précision d'une décimale
float(1.5)
float(-1.5)

Voir aussi

ceil() - Arrondit au nombre supérieur
floor() - Arrondit à l'entier inférieur
number_format() - Formate un nombre pour l'affichage

Found A Problem?

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

＋add a note

User Contributed Notes 13 notes

down

324

takingsides at gmail dot com ¶

10 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);
}
?>

down

depaula at unilogica dot com ¶

7 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

down

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)

down

djcox99 at googlemail dot com ¶

10 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.

down

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

?>

down

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

down

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 .

down

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);

}

?>

down

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

?>

down

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

?>

down

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
 * 
 */

down

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;

}

?>

down

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));

＋add a note