round()

(PHP 4, PHP 5, PHP 7)

对浮点数进行四舍五入

说明

返回将$val根据指定精度$precision（十进制小数点后数字的数目）进行四舍五入的结果。$precision也可以是负数或零（默认值）。

Note:PHP 默认不能正确处理类似"12,300.2"的字符串。见字符串转换为数值。

参数

要处理的值

可选的十进制小数点后数字的数目。

以下之一：PHP_ROUND_HALF_UP、PHP_ROUND_HALF_DOWNPHP_ROUND_HALF_EVEN或PHP_ROUND_HALF_ODD

返回值

四舍五入后的值

范例

Example #1round()例子

Example #2$mode例子

更新日志

参见

• ceil() 进一法取整
• floor() 舍去法取整
• number_format() 以千位分隔符方式格式化一个数字

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. 

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)

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.

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

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.

PHP 5.3, 5.4, 5.5

PHP 5.6

PHP 7 

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:

This returns: 3.40 .

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

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. 

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

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:

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

Please note that the format of this functions output also depends on your locale settings. For example, if you have set your locale to some country that uses commas to separate decimal places, the output of this function also uses commas instead of dots.
This might be a problem when you are feeding the rounded float number into a database, which requires you to separate decimal places with dots.
See it in action:

The output will be:
3.56
3,56

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! 

Excel-like ROUNDUP function:
public static function round_up($value, $places) 
{
  $mult = pow(10, abs($places)); 
   return $places 
Unexpected result or misunderstanding (php v5.5.9) 
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));
When you have a deal with money like dollars, you need to display it under this condition:
-format all number with two digit decimal for cents.
-divide 1000 by ,
-round half down for number with more than two decimal
I approach it using round function inside the number_format function:
number_format((float)round( 625.371 ,2, PHP_ROUND_HALF_DOWN),2,'.',',') // 625.37
number_format((float)round( 625.379 ,2, PHP_ROUND_HALF_DOWN),2,'.',',') // 625.38
number_format((float)round( 1211.20 ,2, PHP_ROUND_HALF_DOWN),2,'.',',') // 1,211.20
number_format((float)round( 625 ,2, PHP_ROUND_HALF_DOWN),2,'.',',')   // 625.00
Solving round_down() problem: 
-----------------------------
Use of  fails in some cases, e.g. round_down(2.05, 2) gives incorrect 2.04.
Here is a "string" solution (https://stackoverflow.com/a/26491492/1245149) of the problem (a negative precision is not covered):

Solving round_up() problem:
---------------------------
Use of  fails in some cases, e.g. round_up(2.22, 2) gives incorrect 2.23 (https://stackoverflow.com/a/8239620/1245149).
Adapting the above round_down() "string" solution I have got this result (a negative precision is not covered):

I don't know it is bulletproof, but at least it removes the above mentioned fail. I have done no binary-to-decimal-math-analysis but if `$floorValue + pow(10, 0 - $precision)` works
always as expected then it should be ok.
It should just be noted that what is called "precision" on this page is more correctly called accuracy; precision is the total number of significant digits on both sides of the decimal point, while accuracy is the number of digits to the right of the point. It's a common confusion.
Note that PHP 5.3 didn't just introduce $mode, it rewrote the rounding implementation completely to eliminate many kinds of rounding errors common to rounding floating point values.
That's why round() gives you the correct result even when floor/ceil don't.
For example, floor(0.285 * 100 + 0.5) VS round(0.285*100 + 0.5). First one gives 28, second one gives 29.
More details here: https://wiki.php.net/rfc/rounding
/**
 * 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
 * 
 */
This functions return ceil($nb) if the double or float value is bigger than "$nb.5" else it's return floor($nb) 
Here is a short neat function to round minutes (hour) ...

You decide to round to nearest minute ...
example will produce : 14:05
In case someone will need a "graceful" rounding (that changes it's precision to get a non 0 value) here's a simple function:
function gracefulRound($val, $min = 2, $max = 4) {
  $result = round($val, $min);
  if ($result == 0 && $min 
To round any number to a given number of significant digits, use log10 to find out its magnitude:

Or when you have to display a per-unit price which may work out to be less than a few cents/pence/yen you can use:

This always displays at least the number of decimal places required by the currency, but more if displaying the unit price with precision requires it - eg: 'English proofreading from $0.0068 per word', 'English beer from $6.80 per pint'.
This function has strange. behaviors:

returns:
141.07
on my machine.
So never really trust this function when you do critical calculations like accounting stuff!
Instead: use only integers or use string comparisons.
Since the mode parameter for options like PHP_ROUND_HALF_UP is available as of PHP 5.3, here is an alternative for ceiling:

If I round this:

You can also use a ceil (which might be useful for pagination):

[Edited by: googleguy@php.net for clarity]
Formats a number to the specified number of significant figures. 
$a = .9;
  $b = .8;
  $d = .1;
  $e = .2;
  $x = $a-$b;
  $y = $e-$d;
  $f = round($x,2);
  echo $f;
  if($f==$y){
    echo "ok";
  }
 

鹏仔微信 15129739599 鹏仔QQ344225443 鹏仔前端 pjxi.com 共享博客 sharedbk.com