我试图将十进制数字截断到小数位。像这样:
5.467 -> 5.46
985.943 -> 985.94
toFixed(2)
所做的只是正确的事情,但是却舍入了价值。我不需要四舍五入的价值。希望这是可能的JavaScript。
我试图将十进制数字截断到小数位。像这样:
5.467 -> 5.46
985.943 -> 985.94
toFixed(2)
所做的只是正确的事情,但是却舍入了价值。我不需要四舍五入的价值。希望这是可能的JavaScript。
Answers:
更新:
因此,无论如何,四舍五入的bug总是会困扰着您,无论您如何努力补偿它们。因此,应该通过精确地用十进制表示法来解决该问题。
Number.prototype.toFixedDown = function(digits) {
var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
m = this.toString().match(re);
return m ? parseFloat(m[1]) : this.valueOf();
};
[ 5.467.toFixedDown(2),
985.943.toFixedDown(2),
17.56.toFixedDown(2),
(0).toFixedDown(1),
1.11.toFixedDown(1) + 22];
// [5.46, 985.94, 17.56, 0, 23.1]
旧的易于出错的解决方案基于其他人的编译:
Number.prototype.toFixedDown = function(digits) {
var n = this - Math.pow(10, -digits)/2;
n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
return n.toFixed(digits);
}
1.11.toFixedDown(1) + 22
以1.122
代替23.1
。也0.toFixedDown(1)
应该产生,0
但是它产生-0.1
。
(-10.2131).toFixedDown(2) // ==> 10.21
。
(1e-7).toFixedDown(0) // ==> 1e-7
。这是否为1e-(>=7)
(例如:1e-8
,1e-9
,...)。
Dogbert的答案很好,但是如果您的代码可能必须处理负数,则Math.floor
其本身可能会产生意外的结果。
例如Math.floor(4.3) = 4
,但是Math.floor(-4.3) = -5
使用类似这样的帮助器函数来获得一致的结果:
truncateDecimals = function (number) {
return Math[number < 0 ? 'ceil' : 'floor'](number);
};
// Applied to Dogbert's answer:
var a = 5.467;
var truncated = truncateDecimals(a * 100) / 100; // = 5.46
这是此功能的一个更方便的版本:
truncateDecimals = function (number, digits) {
var multiplier = Math.pow(10, digits),
adjustedNum = number * multiplier,
truncatedNum = Math[adjustedNum < 0 ? 'ceil' : 'floor'](adjustedNum);
return truncatedNum / multiplier;
};
// Usage:
var a = 5.467;
var truncated = truncateDecimals(a, 2); // = 5.46
// Negative digits:
var b = 4235.24;
var truncated = truncateDecimals(b, -2); // = 4200
如果这不是您期望的行为,请Math.abs
在第一行插入一个呼叫:
var multiplier = Math.pow(10, Math.abs(digits)),
编辑: shendz正确指出,使用此解决方案a = 17.56
会错误地产生17.55
。有关为什么会发生这种情况的更多信息,请阅读每个计算机科学家应该了解的有关浮点算法的知识。。不幸的是,使用javascript编写消除所有浮点错误源的解决方案非常棘手。在另一种语言中,您可能会使用整数或十进制类型,但使用javascript ...
该解决方案应该是100%准确的,但是也会慢一些:
function truncateDecimals (num, digits) {
var numS = num.toString(),
decPos = numS.indexOf('.'),
substrLength = decPos == -1 ? numS.length : 1 + decPos + digits,
trimmedResult = numS.substr(0, substrLength),
finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;
return parseFloat(finalResult);
}
对于那些既需要速度又希望避免浮点错误的人,请尝试使用BigDecimal.js之类的方法。您可以在此问题中找到其他javascript BigDecimal库:“是否有一个好的Javascript BigDecimal库?” 这是关于Java语言数学库的一篇不错的博客文章
if(isNAN(result) result = 0;
取决于您想要的行为。
var a = 5.467;
var truncated = Math.floor(a * 100) / 100; // = 5.46
truncate(-3.14)
和接收-4
回来,我肯定会称之为不可取。
var a = 65.1
var truncated = Math.floor(a * 100) / 100; // = 65.09
因此,这不是一个正确的解决方案
考虑利用双波浪号:~~
。
输入号码。乘以小数点后的有效数字,以便您可以使用截断至零位~~
。再除以该乘数。利润。
function truncator(numToTruncate, intDecimalPlaces) {
var numPower = Math.pow(10, intDecimalPlaces); // "numPowerConverter" might be better
return ~~(numToTruncate * numPower)/numPower;
}
我试图抵制将~~
通话包装在括号内;我相信,操作顺序应该可以使该工作正常进行。
alert(truncator(5.1231231, 1)); // is 5.1
alert(truncator(-5.73, 1)); // is -5.7
alert(truncator(-5.73, 0)); // is -5
编辑:回头看,我也无意间还处理了一些情况,也将小数点后的四舍五入。
alert(truncator(4343.123, -2)); // gives 4300.
逻辑在寻找这种用法时有些古怪,可能会受益于快速重构。但它仍然有效。幸运总比不好好。
Math
以此扩展原型并在执行前检查NaN-s,那将是完美的。
truncator((10 * 2.9) / 100, 2)
返回0.28而不是0.29 ... jsfiddle.net/25tgrzq1
不错的一线解决方案:
function truncate (num, places) {
return Math.trunc(num * Math.pow(10, places)) / Math.pow(10, places);
}
然后调用:
truncate(3.5636232, 2); // returns 3.56
truncate(5.4332312, 3); // returns 5.433
truncate(25.463214, 4); // returns 25.4632
我以为我会用|
它来回答问题,因为它很简单而且效果很好。
truncate = function(number, places) {
var shift = Math.pow(10, places);
return ((number * shift) | 0) / shift;
};
truncate((10 * 2.9) / 100);
此代码返回0.28而不是0.29时不正确jsfiddle.net/9pf0732d
使用按位运算符截断:
~~0.5 === 0
~~(-0.5) === 0
~~14.32794823 === 14
~~(-439.93) === -439
@Dogbert的答案可以通过改进Math.trunc
,该方法会截断而不是舍入。
舍入和截断有区别。截断显然是此问题寻求的行为。如果我调用truncate(-3.14)并收到-4,那肯定是不受欢迎的。– @NickKnowlson
var a = 5.467;
var truncated = Math.trunc(a * 100) / 100; // = 5.46
var a = -5.467;
var truncated = Math.trunc(a * 100) / 100; // = -5.46
我用一个简短的方法写了一个答案。这是我想出的
function truncate(value, precision) {
var step = Math.pow(10, precision || 0);
var temp = Math.trunc(step * value);
return temp / step;
}
该方法可以像这样使用
truncate(132456.25456789, 5)); // Output: 132456.25456
truncate(132456.25456789, 3)); // Output: 132456.254
truncate(132456.25456789, 1)); // Output: 132456.2
truncate(132456.25456789)); // Output: 132456
或者,如果您想使用较短的语法,则可以
function truncate(v, p) {
var s = Math.pow(10, p || 0);
return Math.trunc(s * v) / s;
}
Number.prototype.trim = function(decimals) {
var s = this.toString();
var d = s.split(".");
d[1] = d[1].substring(0, decimals);
return parseFloat(d.join("."));
}
console.log((5.676).trim(2)); //logs 5.67
我认为此功能可能是一个简单的解决方案:
function trunc(decimal,n=2){
let x = decimal + ''; // string
return x.lastIndexOf('.')>=0?parseFloat(x.substr(0,x.lastIndexOf('.')+(n+1))):decimal; // You can use indexOf() instead of lastIndexOf()
}
console.log(trunc(-241.31234,2));
console.log(trunc(241.312,5));
console.log(trunc(-241.233));
console.log(trunc(241.2,0));
console.log(trunc(241));
我发现了一个问题:考虑下一种情况:2.1或1.2或-6.4
如果您想始终使用3个小数,2个或3个小数,该怎么办,因此,您必须在右边填写前导零
// 3 decimals numbers
0.5 => 0.500
// 6 decimals
0.1 => 0.10000
// 4 decimales
-2.1 => -2.1000
// truncate to 3 decimals
3.11568 => 3.115
这是Nick Knowlson的固定功能
function truncateDecimals (num, digits)
{
var numS = num.toString();
var decPos = numS.indexOf('.');
var substrLength = decPos == -1 ? numS.length : 1 + decPos + digits;
var trimmedResult = numS.substr(0, substrLength);
var finalResult = isNaN(trimmedResult) ? 0 : trimmedResult;
// adds leading zeros to the right
if (decPos != -1){
var s = trimmedResult+"";
decPos = s.indexOf('.');
var decLength = s.length - decPos;
while (decLength <= digits){
s = s + "0";
decPos = s.indexOf('.');
decLength = s.length - decPos;
substrLength = decPos == -1 ? s.length : 1 + decPos + digits;
};
finalResult = s;
}
return finalResult;
};
x = 0.0000
测试truncateDecimals (x, 2)
失败。返回0
。与预期0.00
function toFixed(number, digits) {
var reg_ex = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)")
var array = number.toString().match(reg_ex);
return array ? parseFloat(array[1]) : number.valueOf()
}
var test = 10.123456789
var __fixed = toFixed(test, 6)
console.log(__fixed)
// => 10.123456
@kirilloid的答案似乎是正确的答案,但是,主要代码需要更新。他的解决方案不处理负数(有人在注释部分中提到了该负数,但尚未在主代码中对其进行更新)。
将其更新为完整的最终测试解决方案:
Number.prototype.toFixedDown = function(digits) {
var re = new RegExp("([-]*\\d+\\.\\d{" + digits + "})(\\d)"),
m = this.toString().match(re);
return m ? parseFloat(m[1]) : this.valueOf();
};
用法示例:
var x = 3.1415629;
Logger.log(x.toFixedDown(2)); //or use whatever you use to log
小提琴:JS数字四舍五入
PS:没有足够的仓库来评论该解决方案。
Lodash有一些Math实用程序方法,可以对圆形,地板和天花板一些给定的小数精度。这留下了尾随零。
他们使用数字的指数采取了一种有趣的方法。显然,这避免了舍入问题。
(注:func
是Math.round
或ceil
或floor
在下面的代码)
// Shift with exponential notation to avoid floating-point issues.
var pair = (toString(number) + 'e').split('e'),
value = func(pair[0] + 'e' + (+pair[1] + precision));
pair = (toString(value) + 'e').split('e');
return +(pair[0] + 'e' + (+pair[1] - precision));
标记为解决方案的是直到今天我发现的更好的解决方案,但是存在严重的0问题(例如0.toFixedDown(2)给出-0.01)。所以我建议使用这个:
Number.prototype.toFixedDown = function(digits) {
if(this == 0) {
return 0;
}
var n = this - Math.pow(10, -digits)/2;
n += n / Math.pow(2, 53); // added 1360765523: 17.56.toFixedDown(2) === "17.56"
return n.toFixed(digits);
}
const TO_FIXED_MAX = 100;
function truncate(number, decimalsPrecison) {
// make it a string with precision 1e-100
number = number.toFixed(TO_FIXED_MAX);
// chop off uneccessary digits
const dotIndex = number.indexOf('.');
number = number.substring(0, dotIndex + decimalsPrecison + 1);
// back to a number data type (app specific)
return Number.parseFloat(number);
}
// example
truncate(0.00000001999, 8);
0.00000001
适用于:
只是指出一个对我有用的简单解决方案
将其转换为字符串,然后对其进行正则表达式...
var number = 123.45678;
var number_s = '' + number;
var number_truncated_s = number_s.match(/\d*\.\d{4}/)[0]
var number_truncated = parseFloat(number_truncated_s)
可以缩写为
var number_truncated = parseFloat(('' + 123.4568908).match(/\d*\.\d{4}/)[0])
这是您想要做的ES6代码
const truncateTo = (unRouned, nrOfDecimals = 2) => {
const parts = String(unRouned).split(".");
if (parts.length !== 2) {
// without any decimal part
return unRouned;
}
const newDecimals = parts[1].slice(0, nrOfDecimals),
newString = `${parts[0]}.${newDecimals}`;
return Number(newString);
};
// your examples
console.log(truncateTo(5.467)); // ---> 5.46
console.log(truncateTo(985.943)); // ---> 985.94
// other examples
console.log(truncateTo(5)); // ---> 5
console.log(truncateTo(-5)); // ---> -5
console.log(truncateTo(-985.943)); // ---> -985.94
您可以使用字符串。它检查是否为“。” 存在,然后删除字符串的一部分。
截断(7.88,1)-> 7.8
截断(7.889,2)-> 7.89
截断(-7.88,1)-> -7.88
function truncate(number, decimals) {
const tmp = number + '';
if (tmp.indexOf('.') > -1) {
return +tmp.substr(0 , tmp.indexOf('.') + decimals+1 );
} else {
return +number
}
}
我对为什么这么简单的问题有这么多不同的答案感到困惑。我发现只有两种方法值得研究。我做了一个快速基准测试,看看使用https://jsbench.me/。
这是当前(2020/9/26)标记为答案的解决方案:
function truncate(n, digits) {
var re = new RegExp("(\\d+\\.\\d{" + digits + "})(\\d)"),
m = n.toString().match(re);
return m ? parseFloat(m[1]) : n.valueOf();
};
[ truncate(5.467,2),
truncate(985.943,2),
truncate(17.56,2),
truncate(0, 1),
truncate(1.11, 1) + 22];
但是,这是在做字符串和正则表达式的东西,通常效率不高,并且有一个Math.trunc函数可以精确地执行执行OP想要的操作,而没有小数。因此,您可以轻松地使用它加上一些额外的算法来获得相同的结果。
这是我在此线程上找到的另一种解决方案,即我将使用的解决方案:
function truncate(n, digits) {
var step = Math.pow(10, digits || 0);
var temp = Math.trunc(step * n);
return temp / step;
}
[ truncate(5.467,2),
truncate(985.943,2),
truncate(17.56,2),
truncate(0, 1),
truncate(1.11, 1) + 22];
第一种方法比第二种方法“慢99.92%”,因此第二种肯定是我建议使用的方法。
好吧,回到寻找避免工作的其他方式...