我的扩展圆函数:

function round(value, precision) {
  if (Number.isInteger(precision)) {
    var shift = Math.pow(10, precision);
    // Limited preventing decimal issue
    return (Math.round( value * shift + 0.00000000000001 ) / shift);
  } else {
    return Math.round(value);
  }
} 

示例输出:

round(123.688689)     // 123
round(123.688689, 0)  // 123
round(123.688689, 1)  // 123.7
round(123.688689, 2)  // 123.69
round(123.688689, -2) // 100
round(1.015, 2) // 1.02

如果你不仅想在浮动上使用toFixed()，而且还想使用ceil()和floor()，那么你可以使用以下函数:

function roundUsing(func, number, prec) {
    var tempnumber = number * Math.pow(10, prec);
    tempnumber = func(tempnumber);
    return tempnumber / Math.pow(10, prec);
}

生产:

> roundUsing(Math.floor, 0.99999999, 3)
0.999
> roundUsing(Math.ceil, 0.1111111, 3)
0.112

UPD:

另一种可能的方式是:

Number.prototype.roundUsing = function(func, prec){
    var temp = this * Math.pow(10, prec)
    temp = func(temp);
    return temp / Math.pow(10, prec)
}

生产:

> 6.688689.roundUsing(Math.ceil, 1)
6.7
> 6.688689.roundUsing(Math.round, 1)
6.7
> 6.688689.roundUsing(Math.floor, 1)
6.6

> +(6.688687).toPrecision(2)
6.7

JavaScript中的Number对象有一个方法，它可以完全满足您的需要。该方法是Number.toPrecision([precision])。

就像. tofixed(1)一样，它将结果转换为字符串，并且需要将其转换回数字。这里使用+前缀完成。

在我的笔记本电脑上进行简单的基准测试:

number = 25.645234 typeof number
50000000 x number.toFixed(1) = 25.6 typeof string / 17527ms
50000000 x +(number.toFixed(1)) = 25.6 typeof number / 23764ms
50000000 x number.toPrecision(3) = 25.6 typeof string / 10100ms
50000000 x +(number.toPrecision(3)) = 25.6 typeof number / 18492ms
50000000 x Math.round(number*10)/10 = 25.6 typeof number / 58ms
string = 25.645234 typeof string
50000000 x Math.round(string*10)/10 = 25.6 typeof number / 7109ms

我的扩展圆函数:

function round(value, precision) {
  if (Number.isInteger(precision)) {
    var shift = Math.pow(10, precision);
    // Limited preventing decimal issue
    return (Math.round( value * shift + 0.00000000000001 ) / shift);
  } else {
    return Math.round(value);
  }
} 

示例输出:

round(123.688689)     // 123
round(123.688689, 0)  // 123
round(123.688689, 1)  // 123.7
round(123.688689, 2)  // 123.69
round(123.688689, -2) // 100
round(1.015, 2) // 1.02

如何正确舍入小数在一个数字(基础): 我们从最右边的数字开始:

如果这个数字>= 5需要四舍五入，那么我们将向左边的第一个数字报告一个1。 如果这个数字< 5表示没有四舍五入

一旦您知道是否需要报告一个值，您就可以删除最后一个数字并重复该操作。

如果有要报告的值，则首先将其添加到最右侧的新数字，然后再重复前面的测试。

注意，有一种特殊情况，当您需要报告一个值，而必须添加到该值的数字是9时:在这种情况下，您必须将数字值更改为0，然后再报告左边接下来的数字为1。

对于一些失败的答案，它看起来像小数被从左到右分割为所需数量的小数，甚至不关心四舍五入。

现在这里声明的是一个函数，它将使用上述逻辑递归地舍入所提供的浮点值。

function roundFloatR(n, precision = 0, opts = { return: 'number' }) { // Use recursivity

    if ( precision == 0 ) { // n will be rounded to the closest integer

        if (opts.return == 'number') return Math.round(n);
        else if (opts.return == 'string') return `${Math.round(n)}`;
    
    } else {

        let ns = `${n}`.split(''); // turns float into a string before splitting it into a char array    

        if ( precision < 0 ) { // precision is a negative number
            precision += ns.length - 1; // precision equals last index of ns - its actual value 

        } else if ( precision > 0 ) { // precision is a positive number
            if ( ns.indexOf('.') > -1 ) 
                precision += ns.indexOf('.'); // precision equals its value + the index of the float separator in the string / array of char
        }

        // RECURSIVE FUNCTION: loop from the end of ns to the precision index while rounding the values
        // index: index in the ns char array, rep: reported value, (INTERNAL_VAR, cn: current number)
        const recursive = (index, rep) => { 
            let cn = parseInt(ns[index]); // get the current number from ns at index

            if (index <= precision) { // current index inferior or equal to the defined precision index (end of rounding) 

                if (rep) { // if a reported value exists
                    cn += rep; // add reported value to current number 

                    if (cn == 10) { // extends rounding for special case of decimals ending with 9 + reported value 
                        ns[index] = '0';
                        recursive( (index - 1), 1 ); // calls recursive() again with a reported value

                    } else if (cn < 10) 
                        ns[index] = `${cn}`;    
                }

            } else if (index > precision) { // current index superior to defined precision index  

                ns.pop(); // each passage in this block will remove the last entry of ns
                if (rep) cn += rep; // adds reported value (if it exists) to current number
                
                if ( cn >= 5 ) // ROUNDING
                    recursive( (index - 1), 1 ); // calls recursive() again with a reported value

                else  // NO ROUNDING
                    recursive( index - 1 ); // calls recursive() again w/o a reported value 
            }  

        }; // end of recursive()

        recursive(ns.length - 1); // starts recursive rounding over the ns char array (arg is the last index of ns)

        if (opts.return == "number") return parseFloat(ns.join('')); // returns float number
        else if (opts.return == "string") return ns.join(''); // returns float number as string
    }

} //

工作原理: 我们首先将提供的float值转换为字符串，然后使用string .split(")指令将其拆分为一个char数组。

然后，我们将以字符数组的最后一个索引作为参数调用递归()函数，在四舍五入值的同时，从最后一个索引遍历该数组到精度索引。

参数说明: 总共有3个参数允许不同的功能。

n: the value to be rounded (number or string). precision: [default = 0] an int which represent the amount of decimals we want to round the provided number to. There are 3 possibilities: precision == 0: value returned will be the same as using the Math.round() method precision > 0: precision will be defined from the float separator index + precision value precision < 0: precision will be defined from the index of the last number - precision value opts: [default = {return: 'number'}] an options object with a unique property called return which take a string value options are 'number' or 'string'. allows the selection of the type of value returned by the function

第2和第3个参数是可选的

用法和示例:

使用浮点值

let n = 20.336099982261654;

let r = roundFloatR(n); // r = 20
r = roundFloatR(n, 2); // r = 20.34

r = roundFloatR(n, 6); // r = 20.3361
r = roundFloatR(n, 6, {return: 'string'}); // r = "20.336100"

// negative precision
r = roundFloatR(n, -2); // r = 20.3360999822617 

使用字符串值

let n = '20.48490002346038';

let r = roundFloatR(n); // r = 20
r = roundFloatR(n, 2); // r = 20.49

r = roundFloatR(n, 6); // r = 20.4849
r = roundFloatR(n, 6, {return: 'string'}); // r = "20.484900"

// negative precision
r = roundFloatR(n, -10); // r = 20.4849

性能如何? 大多数情况下，它将在0.3毫秒以内转换提供的值(用performance.now()测量)

不支持的内容和可能出现的问题:

不支持:指数类型值可能需要一些更改来支持它们。 可能的问题: 负精度值超过所提供的数字长度或其浮动分隔符索引可能会导致意想不到的结果，因为这些情况尚未处理。 如果n参数与当前要求的不匹配，则没有错误处理。

var number = 6.688689;
var roundedNumber = Math.round(number * 10) / 10;