舍入到最多2位小数(仅在必要时)

wqui 发布于 2019-01-26 decimal 最后更新 2019-01-26 11:20 180 浏览

我想最多舍入两位小数,但只有在必要时。 输入:

10
1.7777777
9.1
输出:
10
1.78
9.1
我怎样才能在JavaScript中做到这一点?
已邀请:

lquia

赞同来自:

+(10).toFixed(2); // = 10
+(10.12345).toFixed(2); // = 10.12
(10).toFixed(2); // = 10.00
(10.12345).toFixed(2); // = 10.12

et_et

赞同来自:

我尝试了自己的代码,试试这个

function AmountDispalyFormat(value) {
    value = value.toFixed(3);
    var amount = value.toString().split('.');
    var result = 0;
    if (amount.length > 1) {
        var secondValue = parseInt(amount[1].toString().slice(0, 2));
        if (amount[1].toString().length > 2) {
            if (parseInt(amount[1].toString().slice(2, 3)) > 4) {
                secondValue++;
                if (secondValue == 100) {
                    amount[0] = parseInt(amount[0]) + 1;
                    secondValue = 0;
                }
            }
        }
if (secondValue.toString().length == 1) {
            secondValue = "0" + secondValue;
        }
        result = parseFloat(amount[0] + "." + secondValue);
    } else {
        result = parseFloat(amount);
    }
    return result;
}

lsint

赞同来自:

我为自己写了以下一组函数。也许它也会对你有所帮助。

function float_exponent(number) {
    exponent = 1;
    while (number < 1.0) {
        exponent += 1
        number *= 10
    }
    return exponent;
}
function format_float(number, extra_precision) {
    precision = float_exponent(number) + (extra_precision || 0)
    return number.toFixed(precision).split(/\.?0+$/)[0]
}
用法:
format_float(1.01); // 1
format_float(1.06); // 1.1
format_float(0.126); // 0.13
format_float(0.000189); // 0.00019
对于你的情况:
format_float(10, 1); // 10
format_float(9.1, 1); // 9.1
format_float(1.77777, 1); // 1.78

tut

赞同来自:

MarkG的答案是正确的。这是任意数量小数位的通用扩展。

Number.prototype.round = function(places) {
  return +(Math.round(this + "e+" + places)  + "" + places);
}
用法:
var n = 1.7777;    
n.round(2); // 1.78
单元测试:
it.only('should round floats to 2 places', function() {
var cases = [
    { n: 10,      e: 10,    p:2 },
    { n: 1.7777,  e: 1.78,  p:2 },
    { n: 1.005,   e: 1.01,  p:2 },
    { n: 1.005,   e: 1,     p:0 },
    { n: 1.77777, e: 1.8,   p:1 }
  ]
cases.forEach(function(testCase) {
    var r = testCase.n.round(testCase.p);
    assert.equal(r, testCase.e, 'didn\'t get right number');
  });
})

qnobis

赞同来自:

你应该使用:

Math.round( num * 100 + Number.EPSILON ) / 100
似乎没有人知道Number.EPSILON。 另外值得注意的是,这并不是像某些人所说的JavaScript怪异。 这就是浮点数在计算机中的工作方式。像99%的编程语言一样,JavaScript没有自制的浮点数;它依赖于CPU / FPU。计算机使用二进制,而在二进制中,没有任何数字,如0.1,但仅仅是二进制近似。为什么?出于同样的原因,1/3不能用十进制写:它的值是0.33333333 ......无穷大的三分。 这里有Number.EPSILON。该数字是1和双精度浮点数中存在的下一个数字之间的差值。就是这样:1和1 + Number.EPSILON之间没有数字。

xet

赞同来自:

如果值是文本类型:

parseFloat("123.456").toFixed(2);
如果值是数字:
var numb = 123.23454;
numb = numb.toFixed(2);
有一个缺点,像1.5这样的值会给出“1.50”作为输出。 @minitech建议修复:
var numb = 1.5;
numb = +numb.toFixed(2);
// Note the plus sign that drops any "extra" zeroes at the end.
// It changes the result (which is a string) into a number again (think "0 + foo"),
// which means that it uses only as many digits as necessary.
似乎Math.round是一个更好的解决方案。但事实并非如此!在某些情况下,它不会正确圆:
Math.round(1.005 * 1000)/1000 // Returns 1 instead of expected 1.01!
在某些情况下,toFixed()也不会正确舍入(在Chrome v.55.0.2883.87中测试)! 例子:
parseFloat("1.555").toFixed(2); // Returns 1.55 instead of 1.56.
parseFloat("1.5550").toFixed(2); // Returns 1.55 instead of 1.56.
// However, it will return correct result if you round 1.5551.
parseFloat("1.5551").toFixed(2); // Returns 1.56 as expected.
1.3555.toFixed(3) // Returns 1.355 instead of expected 1.356.
// However, it will return correct result if you round 1.35551.
1.35551.toFixed(2); // Returns 1.36 as expected.
我想,这是因为1.555实际上就像浮动1.55499994幕后。 解决方案1是使用具有所需舍入算法的脚本,例如:
function roundNumber(num, scale) {
  if(!("" + num).includes("e")) {
    return +(Math.round(num + "e+" + scale)  + "" + scale);
  } else {
    var arr = ("" + num).split("e");
    var sig = ""
    if(+arr[1] + scale > 0) {
      sig = "+";
    }
    return +(Math.round(+arr[0] + "e" + sig + (+arr[1] + scale)) + "" + scale);
  }
}
https://plnkr.co/edit/uau8BlS1cqbvWPCHJeOy?p=preview 解决方案2是避免前端计算并从后端服务器中提取舍入值。

hiure

赞同来自:

使用Math.round(num * 100) / 100

iipsa

赞同来自:

这可能对您有所帮助:

var result = (Math.round(input*100)/100);
有关更多信息,您可以查看此链接 Math.round(num) vs num.toFixed(0) and browser inconsistencies

iest

赞同来自:

考虑.toFixed().toPrecision()http://www.javascriptkit.com/javatutors/formatnumber.shtml

tiste

赞同来自:

精确的舍入方法。资料来源:Mozilla

(function(){
/**
     * Decimal adjustment of a number.
     *
     * @param   {String}    type    The type of adjustment.
     * @param   {Number}    value   The number.
     * @param   {Integer}   exp     The exponent (the 10 logarithm of the adjustment base).
     * @returns {Number}            The adjusted value.
     */
    function decimalAdjust(type, value, exp) {
        // If the exp is undefined or zero...
        if (typeof exp === 'undefined' || +exp === 0) {
            return Mathtype;
        }
        value = +value;
        exp = +exp;
        // If the value is not a number or the exp is not an integer...
        if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0)) {
            return NaN;
        }
        // Shift
        value = value.toString().split('e');
        value = Mathtype : -exp)));
        // Shift back
        value = value.toString().split('e');
        return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
    }
// Decimal round
    if (!Math.round10) {
        Math.round10 = function(value, exp) {
            return decimalAdjust('round', value, exp);
        };
    }
    // Decimal floor
    if (!Math.floor10) {
        Math.floor10 = function(value, exp) {
            return decimalAdjust('floor', value, exp);
        };
    }
    // Decimal ceil
    if (!Math.ceil10) {
        Math.ceil10 = function(value, exp) {
            return decimalAdjust('ceil', value, exp);
        };
    }
})();
例子:
// Round
Math.round10(55.55, -1); // 55.6
Math.round10(55.549, -1); // 55.5
Math.round10(55, 1); // 60
Math.round10(54.9, 1); // 50
Math.round10(-55.55, -1); // -55.5
Math.round10(-55.551, -1); // -55.6
Math.round10(-55, 1); // -50
Math.round10(-55.1, 1); // -60
Math.round10(1.005, -2); // 1.01 -- compare this with Math.round(1.005*100)/100 above
// Floor
Math.floor10(55.59, -1); // 55.5
Math.floor10(59, 1); // 50
Math.floor10(-55.51, -1); // -55.6
Math.floor10(-51, 1); // -60
// Ceil
Math.ceil10(55.51, -1); // 55.6
Math.ceil10(51, 1); // 60
Math.ceil10(-55.59, -1); // -55.5
Math.ceil10(-59, 1); // -50

mnam

赞同来自:

它可能适合你,

Math.round(num * 100)/100;
知道toFixed和round之间的区别。您可以查看Math.round(num) vs num.toFixed(0) and browser inconsistencies

ueaque

赞同来自:

有几种方法可以做到这一点。像我这样的人,Lodash的变种

function round(number, precision) {
    var pair = (number + 'e').split('e')
    var value = Math.round(pair[0] + 'e' + (+pair[1] + precision))
    pair = (value + 'e').split('e')
    return +(pair[0] + 'e' + (+pair[1] - precision))
}
用法:
round(0.015, 2) // 0.02
round(1.005, 2) // 1.01
如果您的项目使用jQuery或lodash,您还可以在库中找到正确的round方法。

更新1 我删除了变体n.toFixed(2),因为它不正确。谢谢@ avalanche1

umodi

赞同来自:

2017年结果 只需使用本机代码.toFixed()

number = 1.2345;
number.toFixed(2) // 1.23

jenim

赞同来自:

Node.js的 这在几秒钟内就我在Node.js上的诀窍:
npm install math
资料来源:http://mathjs.org/examples/basic_usage.js.html

enemo

赞同来自:

如果您使用的是lodash库,则可以使用lodash的圆形方法,如下所示。

_.round(number, precision)
例如:
_.round(1.7777777, 2) = 1.78

bea

赞同来自:

使用此函数Number(x).toFixed(2);

tqui

赞同来自:

更简单的ES6方式是

const round = (x, n) => {
    return parseFloat(Math.round(x * Math.pow(10, n)) / Math.pow(10, n)).toFixed(n)
};
此模式还返回所要求的精度。 例如:
round(44.7826456, 4)  // yields 44.7826
round(78.12, 4)       // yields 78.1200

edolor

赞同来自:

这是一个简单的方法:

Math.round(value * 100) / 100
您可能希望继续执行单独的功能来为您执行此操作:
function roundToTwo(value) {
    return(Math.round(value * 100) / 100);
}
然后你只需传入值。 您可以通过添加第二个参数来增强它以舍入到任意数量的小数。
function myRound(value, places) {
    var multiplier = Math.pow(10, places);
return (Math.round(value * multiplier) / multiplier);
}

eet

赞同来自:

试试这个轻量级解决方案:

function round(x, digits){
  return parseFloat(x.toFixed(digits))
}
round(1.222,  2) ;
 // 1.22
 round(1.222, 10) ;
 // 1.222

fillum

赞同来自:

这里找到的答案都不正确。 @stinkycheeseman要求围捕,你们全部围绕这个数字。 要整理,请使用:

Math.ceil(num * 100)/100;

zearum

赞同来自:

我仍然认为没有人给他答案如何只在需要时进行四舍五入。我看到的最简单的方法是检查数字中是否还有小数,如下所示:

var num = 3.21;
if ( (num+"").indexOf('.') >= 0 ) { //at least assert to string first...
    // whatever code you decide to use to round
}

eet

赞同来自:

如果您不想圆整,请使用以下功能。

function ConvertToDecimal(num) {
  num = num.toString(); // If it's not already a String
  num = num.slice(0, (num.indexOf(".")) + 3); // With 3 exposing the hundredths place    
alert('M : ' + Number(num)); // If you need it back as a Number     
}

sesse

赞同来自:

您可以使用

function roundToTwo(num) {    
    return +(Math.round(num + "e+2")  + "e-2");
}
我在MDN上发现了这个。他们的方式避免了1.005的mentioned问题。
roundToTwo(1.005)
1.01
roundToTwo(10)
10
roundToTwo(1.7777777)
1.78
roundToTwo(9.1)
9.1

jiusto

赞同来自:

适用于所有浏览器和精度的通用答案:

function round(num, places) {
      if(!places){
       return Math.round(num);
      }
var val = Math.pow(10, places);
      return Math.round(num * val) / val;
}
round(num, 2);

psed

赞同来自:

这是我想出的一个“向上”的功能。我使用双Math.round来补偿JavaScript的不准确乘法,因此1.005将正确舍入为1.01。

function myRound(number, decimalplaces){
    if(decimalplaces > 0){
        var multiply1 = Math.pow(10,(decimalplaces + 4));
        var divide1 = Math.pow(10, decimalplaces);
        return Math.round(Math.round(number * multiply1)/10000 )/divide1;
    }
    if(decimalplaces < 0){
        var divide2 = Math.pow(10, Math.abs(decimalplaces));
        var multiply2 = Math.pow(10, Math.abs(decimalplaces));
        return Math.round(Math.round(number / divide2) * multiply2);
    }
    return Math.round(number);
}

rsaepe

赞同来自:

只在必要时才实现这种舍入的一种方法是使用Number.prototype.toLocaleString()

myNumber.toLocaleString('en', {maximumFractionDigits:2, useGrouping:false})
这将提供您期望的输出,但作为字符串。如果这不是您期望的数据类型,您仍然可以将它们转换回数字。

trerum

赞同来自:

内容太长未翻译

hhic

赞同来自:

可以使用.toFixed(NumberOfDecimalPlaces)

var str = 10.234.toFixed(2); // => '10.23'
var number = Number(str); // => 10.23

xid

赞同来自:

如果你碰巧已经在使用d3库,他们有一个强大的数字格式库:https://github.com/mbostock/d3/wiki/Formatting 具体舍入在这里:https://github.com/mbostock/d3/wiki/Formatting#d3_round 在您的情况下,答案是:

> d3.round(1.777777, 2)
1.78
> d3.round(1.7, 2)
1.7
> d3.round(1, 2)
1

xet

赞同来自:

MarkG和Lavamantis提供了一个比被接受的解决方案更好的解决方案。遗憾的是他们没有得到更多的赞成! 这是我用来解决浮点小数问题also based on MDN的函数。它比Lavamantis的解决方案更通用(但更简洁):

function round(value, exp) {
  if (typeof exp === 'undefined' || +exp === 0)
    return Math.round(value);
value = +value;
  exp  = +exp;
if (isNaN(value) || !(typeof exp === 'number' && exp % 1 === 0))
    return NaN;
// Shift
  value = value.toString().split('e');
  value = Math.round(+(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp)));
// Shift back
  value = value.toString().split('e');
  return +(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp));
}
使用它:
round(10.8034, 2);      // Returns 10.8
round(1.275, 2);        // Returns 1.28
round(1.27499, 2);      // Returns 1.27
round(1.2345678e+2, 2); // Returns 123.46
与Lavamantis的解决方案相比,我们可以......
round(1234.5678, -2); // Returns 1200
round("123.45");      // Returns 123

zet

赞同来自:

仅仅为了记录,如果想要舍入的数字和数字足够大,理论上缩放方法可以返回无穷大。在JavaScript中不应该是一个问题,因为最大数字是1.7976931348623157e + 308,但如果你正在使用非常大的数字或很多小数位,你可以尝试这个函数:

Number.prototype.roundTo = function(digits)
{
    var str = this.toString();
    var split = this.toString().split('e');
    var scientific = split.length > 1;
    var index;
    if (scientific)
    {
        str = split[0];
        var decimal = str.split('.');
        if (decimal.length < 2)
            return this;
        index = decimal[0].length + 1 + digits;
    }
    else
        index = Math.floor(this).toString().length + 1 + digits;
    if (str.length <= index)
        return this;
    var digit = str[index + 1];
    var num = Number.parseFloat(str.substring(0, index));
    if (digit >= 5)
    {
        var extra = Math.pow(10, -digits);
        return this < 0 ? num - extra : num + extra;
    }
    if (scientific)
        num += "e" + split[1];
    return num;
}

qporro

赞同来自:

var roundUpto = function(number, upto){
    return Number(number.toFixed(upto));
}
roundUpto(0.1464676, 2);
toFixed(2)此处2是我们想要对此数字进行舍入的位数。

qfugit

赞同来自:

要不处理多个0,请使用以下变体:

Math.round(num * 1e2) / 1e2

phic

赞同来自:

这是最简单,更优雅的解决方案(我是世界上最好的解决方案;):

function roundToX(num, X) {    
    return +(Math.round(num + "e+"+X)  + ""+X);
}
//roundToX(66.66666666,2) => 66.67
//roundToX(10,2) => 10
//roundToX(10.904,2) => 10.9

xnemo

赞同来自:

最简单的方法: +num.toFixed(2) 它将它转换为字符串,然后返回到整数/浮点数。

xillum

赞同来自:

在打字稿(Angular 2)中尝试此功能。测试复数小数。

/**
 * @param num numeric to round off
 * @param decToRound desired decimal digit to round
 */
roundNumberDec(num, decToRound) {
    if ([undefined, null, ''].indexOf(num) >= 0) {
        return null;
    }
    if (isNaN(num)) { return null; }
    // check if decimal
    if (num.toString().indexOf('.') > -1) {
        const deci = num.toString().split('.')[1];
        if (deci.length <= decToRound) { return Number(num); }
        let isUp = false; let newDecimal = 0;
        let digi;
        for (let i = deci.length - 1; i > decToRound - 1; i--) {
            digi = Number(Number(deci.charAt(i)) + (isUp ? 1 : 0));
            isUp = digi >= 5;
        }
        const frontDigi = num.toString().substr(0, num.toString().indexOf('.'));
        const dec2dig = '0.' + deci.toString().substr(0, decToRound);
        if (isUp) {
            const rounder = Math.pow(10, decToRound);
            newDecimal = Math.round((Number(dec2dig) + (1 / rounder)) * rounder) / rounder;
        } else {
            newDecimal = Number(dec2dig);
        }
        return Number(Number(frontDigi) + Number(newDecimal));
    } else {
        return Number(num);
    }
}

xid

赞同来自:

尝试使用jQuery .number plug-in

var number = 19.8000000007;
var res = 1 * $.number(number, 2);

inisi

赞同来自:

您还可以覆盖Math.round函数以进行舍入校正并为小数添加参数并使用它:Math.round(Number,Decimals)。请记住,这会覆盖内置组件Math.round,并为其提供另一个属性,然后它是原始的。

var round = Math.round;
Math.round = function (value, decimals) {
  decimals = decimals || 0;
  return Number(round(value + 'e' + decimals) + '' + decimals);
}
然后你可以像这样简单地使用它:
Math.round(1.005, 2);
https://jsfiddle.net/k5tpq3pd/3/

cet

赞同来自:

要在小数位置舍入pos(包括无小数),请执行Math.round(num * Math.pow(10,pos)) / Math.pow(10,pos)

var console = {
 log: function(s) {
  document.getElementById("console").innerHTML += s + "<br/>"
 }
}
var roundDecimals=function(num,pos) {
 return (Math.round(num * Math.pow(10,pos)) / Math.pow(10,pos) );
}
//https://en.wikipedia.org/wiki/Pi
var pi=3.14159265358979323846264338327950288419716939937510;
for(var i=2;i<15;i++) console.log("pi="+roundDecimals(pi,i));
for(var i=15;i>=0;--i) console.log("pi="+roundDecimals(pi,i));
<div id="console" />

kaut

赞同来自:

这是一个原型方法:

Number.prototype.round = function(places){
    places = Math.pow(10, places); 
    return Math.round(this * places)/places;
}
var yournum = 10.55555;
yournum = yournum.round(2);

pnon

赞同来自:

这是最短而完整的答案:

function round(num, decimals) {
        var n = Math.pow(10, decimals);
        return Math.round( (n * num).toFixed(decimals) )  / n;
};
这也处理了将返回1.01的示例情况1.005。

wab

赞同来自:

我只是想根据前面提到的答案分享我的方法: 让我们创建一个函数,将任何给定的数值舍入到给定的小数位数:

function roundWDecimals(n, decimals) {
    if (!isNaN(parseFloat(n)) && isFinite(n)) {
        if (typeof(decimals) == typeof(undefined)) {
            decimals = 0;
        }
        var decimalPower = Math.pow(10, decimals);
        return Math.round(parseFloat(n) * decimalPower) / decimalPower;
    }
    return NaN;
}
并为数字原型引入一种新的“圆形”方法:
Object.defineProperty(Number.prototype, 'round', {
    enumerable: false,
    value: function(decimals) {
        return roundWDecimals(this, decimals);
    }
});
你可以测试它:
function roundWDecimals(n, decimals) {
    if (!isNaN(parseFloat(n)) && isFinite(n)) {
        if (typeof(decimals) == typeof(undefined)) {
            decimals = 0;
        }
        var decimalPower = Math.pow(10, decimals);
        return Math.round(parseFloat(n) * decimalPower) / decimalPower;
    }
    return NaN;
}
Object.defineProperty(Number.prototype, 'round', {
    enumerable: false,
    value: function(decimals) {
        return roundWDecimals(this, decimals);
    }
});
var roundables = [
    {num: 10, decimals: 2},
    {num: 1.7777777, decimals: 2},
    {num: 9.1, decimals: 2},
    {num: 55.55, decimals: 1},
    {num: 55.549, decimals: 1},
    {num: 55, decimals: 0},
    {num: 54.9, decimals: 0},
    {num: -55.55, decimals: 1},
    {num: -55.551, decimals: 1},
    {num: -55, decimals: 0},
    {num: 1.005, decimals: 2},
    {num: 1.005, decimals: 2},
    {num: 19.8000000007, decimals: 2},
  ],
  table = '<table border="1"><tr><th>Num</th><th>Decimals</th><th>Result</th></tr>';
$.each(roundables, function() {
  table +=
    '<tr>'+
      '<td>'+this.num+'</td>'+
      '<td>'+this.decimals+'</td>'+
      '<td>'+this.num.round(this.decimals)+'</td>'+
    '</tr>'
  ;
});
table += '</table>';
$('.results').append(table);
<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
<div class="results"></div>

et_et

赞同来自:

我将再添加一个方法。

number = 16.6666666;
console.log(parseFloat(number.toFixed(2)));
"16.67"
number = 16.6;
console.log(parseFloat(number.toFixed(2)));
"16.6"
number = 16;
console.log(parseFloat(number.toFixed(2)));
"16"
.toFixed(2)返回一个带有2个小数点的字符串,可能是也可能不是尾随零。执行parseFloat()将消除那些尾随零。