小开

最佳答案

将数字转换为字符串，匹配到小数点后第二位:

function calc(theform) {
var num = theform.original.value, rounded = theform.rounded
var with2Decimals = num.toString().match(/^-?\d+(?:\.\d{0,2})?/)[0]
rounded.value = with2Decimals
}

<form onsubmit="return calc(this)">
Original number: <input name="original" type="text" onkeyup="calc(form)" onchange="calc(form)" />
<br />"Rounded" number: <input name="rounded" type="text" placeholder="readonly" readonly>
</form>

toFixed方法在某些情况下会失败，不像toString，所以要非常小心。

小开

2016年11月5日更新

新的答案，总是准确的

function toFixed(num, fixed) {
var re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fixed || -1) + '})?');
return num.toString().match(re)[0];
}

由于javascript中的浮点数学总是有边缘情况，以前的解决方案在大多数情况下是准确的，这是不够好的。有一些解决方案，如num.toPrecision， BigDecimal.js和accounting.js。然而，我相信仅仅解析字符串将是最简单的，并且总是准确的

基于@Gumbo接受的答案的良好编写的正则表达式的更新，这个新的toFixed函数将始终按预期工作。

老答案，并不总是准确的。

固定功能:

function toFixed(num, fixed) {
fixed = fixed || 0;
fixed = Math.pow(10, fixed);
return Math.floor(num * fixed) / fixed;
}

小开

我选择写这个来手动删除剩余的字符串，这样我就不必处理数字带来的数学问题:

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

这将得到“15.77”，其中num = 15.7784514;

小开

parseInt比Math.floor快

function floorFigure(figure, decimals){
if (!decimals) decimals = 2;
var d = Math.pow(10,decimals);
return (parseInt(figure*d)/d).toFixed(decimals);
};


floorFigure(123.5999)    =>   "123.59"
floorFigure(123.5999, 3) =>   "123.599"

小开

由于马丁Varmus

function floorFigure(figure, decimals){
if (!decimals) decimals = 2;
var d = Math.pow(10,decimals);
return ((figure*d)/d).toFixed(decimals);
};


floorFigure(123.5999)    =>   "123.59"
floorFigure(123.5999, 3) =>   "123.599"

我做了一个简单的更新，我得到了适当的舍入。更新如下

return ((figure*d)/d).toFixed(decimals);

删除parseInt()函数

小开

这些解决方案确实有效，但对我来说似乎没有必要这么复杂。我个人喜欢用模运算符来得到除法运算的余数，然后去掉余数。假设num = 15.7784514:

num-=num%.01;

这相当于说num = num - (num % .01)。

小开

滚动你自己的toFixed函数:对于正值Math.floor工作正常。

function toFixed(num, fixed) {
fixed = fixed || 0;
fixed = Math.pow(10, fixed);
return Math.floor(num * fixed) / fixed;
}

对于负值，Math.floor是值的整数。所以你可以使用Math.ceil代替。

< p >,

Math.ceil(-15.778665 * 10000) / 10000 = -15.7786
Math.floor(-15.778665 * 10000) / 10000 = -15.7787 // wrong.

小开

这里的答案对我没有帮助，它总是四舍五入，或者给我错误的小数。

我的解决方案将您的小数转换为字符串，提取字符，然后将整个东西作为数字返回。

function Dec2(num) {
num = String(num);
if(num.indexOf('.') !== -1) {
var numarr = num.split(".");
if (numarr.length == 1) {
return Number(num);
}
else {
return Number(numarr[0]+"."+numarr[1].charAt(0)+numarr[1].charAt(1));
}
}
else {
return Number(num);
}
}


Dec2(99); // 99
Dec2(99.9999999); // 99.99
Dec2(99.35154); // 99.35
Dec2(99.8); // 99.8
Dec2(10265.985475); // 10265.98

小开

给你。另一种解决问题的方法:

// For the sake of simplicity, here is a complete function:
function truncate(numToBeTruncated, numOfDecimals) {
var theNumber = numToBeTruncated.toString();
var pointIndex = theNumber.indexOf('.');
return +(theNumber.slice(0, pointIndex > -1 ? ++numOfDecimals + pointIndex : undefined));
}

注意在最后一个表达式之前使用了+。这就是将截断的、切片的字符串转换回数字类型。

希望能有所帮助!

小开

下面的代码对我来说很好:

num.toString().match(/.\*\\..{0,2}|.\*/)[0];

小开

Gumbo的第二个解决方案，使用正则表达式，可以工作，但由于使用正则表达式，速度较慢。由于浮点数不精确，Gumbo的第一个解决方案在某些情况下会失败。有关演示和基准测试，请参阅JSFiddle。在我目前使用的3.30 GHz Intel酷睿i5-2500 CPU系统上，第二个解决方案每次调用大约需要1636纳秒。

我所编写的解决方案包括添加一个小的补偿来处理浮点的不精确性。它基本上是瞬时的，即在纳秒的数量级上。我每次调用的时间是2纳秒，但JavaScript计时器不是非常精确或粒度。下面是JS小提琴和代码。

function toFixedWithoutRounding (value, precision)
{
var factorError = Math.pow(10, 14);
var factorTruncate = Math.pow(10, 14 - precision);
var factorDecimal = Math.pow(10, precision);
return Math.floor(Math.floor(value * factorError + 1) / factorTruncate) / factorDecimal;
}


var values = [1.1299999999, 1.13, 1.139999999, 1.14, 1.14000000001, 1.13 * 100];


for (var i = 0; i < values.length; i++)
{
var value = values[i];
console.log(value + " --> " + toFixedWithoutRounding(value, 2));
}


for (var i = 0; i < values.length; i++)
{
var value = values[i];
console.log(value + " --> " + toFixedWithoutRounding(value, 4));
}


console.log("type of result is " + typeof toFixedWithoutRounding(1.13 * 100 / 100, 2));


// Benchmark
var value = 1.13 * 100;
var startTime = new Date();
var numRun = 1000000;
var nanosecondsPerMilliseconds = 1000000;


for (var run = 0; run < numRun; run++)
toFixedWithoutRounding(value, 2);


var endTime = new Date();
var timeDiffNs = nanosecondsPerMilliseconds * (endTime - startTime);
var timePerCallNs = timeDiffNs / numRun;
console.log("Time per call (nanoseconds): " + timePerCallNs);

小开

我使用(num-0.05).toFixed(1)来获得小数小数的第二位。

小开

下面是另一个保存.toFixed([digits])函数而不舍入浮点变量的变体:

Number.prototype.toRealFixed = function(digits) {
return Math.floor(this.valueOf() * Math.pow(10, digits)) / Math.pow(10, digits);
};

和要求:

var float_var = 0.02209062;
float_var.toRealFixed();

小开

已经有一些合适的答案与正则表达式和算术计算，你也可以试试这个

function myFunction() {
var str = 12.234556;
str = str.toString().split('.');
var res = str[1].slice(0, 2);
document.getElementById("demo").innerHTML = str[0]+'.'+res;
}


// output: 12.23

小开

我对正数的看法是:

function toFixed_norounding(n,p)
{
var result = n.toFixed(p);
return result <= n ? result: (result - Math.pow(0.1,p)).toFixed(p);
}

快，漂亮，明显。(正数版本)

小开

在大卫·D的上构建答案:

function NumberFormat(num,n) {
var num = (arguments[0] != null) ? arguments[0] : 0;
var n = (arguments[1] != null) ? arguments[1] : 2;
if(num > 0){
num = String(num);
if(num.indexOf('.') !== -1) {
var numarr = num.split(".");
if (numarr.length > 1) {
if(n > 0){
var temp = numarr[0] + ".";
for(var i = 0; i < n; i++){
if(i < numarr[1].length){
temp += numarr[1].charAt(i);
}
}
num = Number(temp);
}
}
}
}
return Number(num);
}


console.log('NumberFormat(123.85,2)',NumberFormat(123.85,2));
console.log('NumberFormat(123.851,2)',NumberFormat(123.851,2));
console.log('NumberFormat(0.85,2)',NumberFormat(0.85,2));
console.log('NumberFormat(0.851,2)',NumberFormat(0.851,2));
console.log('NumberFormat(0.85156,2)',NumberFormat(0.85156,2));
console.log('NumberFormat(0.85156,4)',NumberFormat(0.85156,4));
console.log('NumberFormat(0.85156,8)',NumberFormat(0.85156,8));
console.log('NumberFormat(".85156",2)',NumberFormat(".85156",2));
console.log('NumberFormat("0.85156",2)',NumberFormat("0.85156",2));
console.log('NumberFormat("1005.85156",2)',NumberFormat("1005.85156",2));
console.log('NumberFormat("0",2)',NumberFormat("0",2));
console.log('NumberFormat("",2)',NumberFormat("",2));
console.log('NumberFormat(85156,8)',NumberFormat(85156,8));
console.log('NumberFormat("85156",2)',NumberFormat("85156",2));
console.log('NumberFormat("85156.",2)',NumberFormat("85156.",2));


// NumberFormat(123.85,2) 123.85
// NumberFormat(123.851,2) 123.85
// NumberFormat(0.85,2) 0.85
// NumberFormat(0.851,2) 0.85
// NumberFormat(0.85156,2) 0.85
// NumberFormat(0.85156,4) 0.8515
// NumberFormat(0.85156,8) 0.85156
// NumberFormat(".85156",2) 0.85
// NumberFormat("0.85156",2) 0.85
// NumberFormat("1005.85156",2) 1005.85
// NumberFormat("0",2) 0
// NumberFormat("",2) 0
// NumberFormat(85156,8) 85156
// NumberFormat("85156",2) 85156
// NumberFormat("85156.",2) 85156

小开

更新(2021年1月)

根据它的范围，javascript中的数字可能以科学计数法显示。例如，如果您在控制台中键入0.0000001，您可能会看到它是1e-7，而0.000001显示为不变(0.000001)。如果应用程序处理的数字范围不涉及科学计数法，则可以忽略此更新并使用下面的原始答案。

这次更新增加了一个函数，检查数字是否为科学格式，如果是，则将其转换为十进制格式。这里我建议使用一个，但你可以使用任何其他函数来实现相同的目标，根据你的应用程序的需要:

function toFixed(x) {
if (Math.abs(x) < 1.0) {
let e = parseInt(x.toString().split('e-')[1]);
if (e) {
x *= Math.pow(10,e-1);
x = '0.' + (new Array(e)).join('0') + x.toString().substring(2);
}
} else {
let e = parseInt(x.toString().split('+')[1]);
if (e > 20) {
e -= 20;
x /= Math.pow(10,e);
x += (new Array(e+1)).join('0');
}
}
return x;
}

现在只需将该函数应用于参数(这是相对于原始答案的唯一变化):

function toFixedTrunc(x, n) {
x = toFixed(x)


// From here on the code is the same than the original answer
const v = (typeof x === 'string' ? x : x.toString()).split('.');
if (n <= 0) return v[0];
let f = v[1] || '';
if (f.length > n) return `${v[0]}.${f.substr(0,n)}`;
while (f.length < n) f += '0';
return `${v[0]}.${f}`
}

这个更新的版本还解决了一个评论中提到的情况:

toFixedTrunc(0.000000199, 2) => "0.00"

同样，选择最适合应用程序需求的。

原答案(2017年10月)

对于任意n≥0，将数字截断(不舍入)到第n位十进制数字并将其转换为恰好有n位十进制数字的字符串的通解。

function toFixedTrunc(x, n) {
const v = (typeof x === 'string' ? x : x.toString()).split('.');
if (n <= 0) return v[0];
let f = v[1] || '';
if (f.length > n) return `${v[0]}.${f.substr(0,n)}`;
while (f.length < n) f += '0';
return `${v[0]}.${f}`
}

其中x可以是一个数字(转换为字符串)或字符串。

下面是n=2的一些测试(包括OP要求的测试):

0           => 0.00
0.01        => 0.01
0.5839      => 0.58
0.999       => 0.99
1.01        => 1.01
2           => 2.00
2.551       => 2.55
2.99999     => 2.99
4.27        => 4.27
15.7784514  => 15.77
123.5999    => 123.59

对于n的其它值:

15.001097   => 15.0010 (n=4)
0.000003298 => 0.0000032 (n=7)
0.000003298257899 => 0.000003298257 (n=12)

小开

num = 19.66752
f = num.toFixed(3).slice(0,-1)
alert(f)

这将返回19.66

小开

另一个单线解决方案:

number = Math.trunc(number*100)/100

我使用100是因为你想截断到第二位，但更灵活的解决方案是:

number = Math.trunc(number*Math.pow(10, digits))/Math.pow(10, digits)

其中digits是要保留的十进制数字的数量。

详细信息和浏览器兼容性请参见数学。trunc规格。

小开

我固定使用以下简单的方法-

var num = 15.7784514;
Math.floor(num*100)/100;

结果将是15.77

小开

简单的做这个

number = parseInt(number * 100)/100;

小开

截断不带零

function toTrunc(value,n){
return Math.floor(value*Math.pow(10,n))/(Math.pow(10,n));
}

或

function toTrunc(value,n){
x=(value.toString()+".0").split(".");
return parseFloat(x[0]+"."+x[1].substr(0,n));
}

测试:

toTrunc(17.4532,2)  //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1)   //1.4
toTrunc(.4,2)       //0.4

用零截断

function toTruncFixed(value,n){
return toTrunc(value,n).toFixed(n);
}

测试:

toTrunc(17.4532,2)  //17.45
toTrunc(177.4532,1) //177.4
toTrunc(1.4532,1)   //1.4
toTrunc(.4,2)       //0.40

小开

不舍入得到两个浮点数更可靠。

参考答案 .

var number = 10.5859;
var fixed2FloatPoints = parseInt(number * 100) / 100;
console.log(fixed2FloatPoints);

谢谢你！

小开

这是用字符串做的

export function withoutRange(number) {
const str = String(number);
const dotPosition = str.indexOf('.');
if (dotPosition > 0) {
const length = str.substring().length;
const end = length > 3 ? 3 : length;
return str.substring(0, dotPosition + end);
}
return str;
}

小开

下面是一种简单的方法，但必须确保amount参数以字符串形式给出。

function truncate(amountAsString, decimals = 2){
var dotIndex = amountAsString.indexOf('.');
var toTruncate = dotIndex !== -1  && ( amountAsString.length > dotIndex + decimals + 1);
var approach = Math.pow(10, decimals);
var amountToTruncate = toTruncate ? amountAsString.slice(0, dotIndex + decimals +1) : amountAsString;
return toTruncate
?  Math.floor(parseFloat(amountToTruncate) * approach ) / approach
:  parseFloat(amountAsString);

｝

console.log(truncate("7.99999")); //OUTPUT ==> 7.99
console.log(truncate("7.99999", 3)); //OUTPUT ==> 7.999
console.log(truncate("12.799999999999999")); //OUTPUT ==> 7.99

小开

这对我来说很有效。我希望它也能解决你的问题。

function toFixedNumber(number) {
const spitedValues = String(number.toLocaleString()).split('.');
let decimalValue = spitedValues.length > 1 ? spitedValues[1] : '';
decimalValue = decimalValue.concat('00').substr(0,2);


return '$'+spitedValues[0] + '.' + decimalValue;
}


// 5.56789      ---->  $5.56
// 0.342        ---->  $0.34
// -10.3484534  ---->  $-10.34
// 600          ---->  $600.00

function convertNumber(){
var result = toFixedNumber(document.getElementById("valueText").value);
document.getElementById("resultText").value = result;
}




function toFixedNumber(number) {
const spitedValues = String(number.toLocaleString()).split('.');
let decimalValue = spitedValues.length > 1 ? spitedValues[1] : '';
decimalValue = decimalValue.concat('00').substr(0,2);


return '$'+spitedValues[0] + '.' + decimalValue;
}

<div>
<input type="text" id="valueText" placeholder="Input value here..">
<br>
<button onclick="convertNumber()" >Convert</button>
<br><hr>
<input type="text" id="resultText" placeholder="result" readonly="true">
</div>

小开

只需要截断数字:

function truncDigits(inputNumber, digits) {
const fact = 10 ** digits;
return Math.floor(inputNumber * fact) / fact;
}

小开

所有这些答案似乎都有点复杂。我只需从你的数字中减去0.5，然后使用toFixed()。

小开

最有效的解决方案(对于2个分数位数)是在调用toFixed()之前减去0.005

function toFixed2( num ) { return (num-0.005).toFixed(2) }

负数也会四舍五入(远离零)。运算符里没有提到负数。

小开

我知道已经有一些工作示例，但我认为值得提出我的String。对于固定等价物，有些人可能会发现它很有用。

这是我的toFixed替代方案，不四舍五入的数字，只是截断它或根据给定的精度加零。对于超长的数字，当精度太长时，它使用JS内置的舍入。函数适用于我在堆栈中发现的所有有问题的数字

function toFixedFixed(value, precision = 0) {
let stringValue = isNaN(+value) ? '0' : String(+value);


if (stringValue.indexOf('e') > -1 || stringValue === 'Infinity' || stringValue === '-Infinity') {
throw new Error('To large number to be processed');
}


let [ beforePoint, afterPoint ] = stringValue.indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];


// Force automatic rounding for some long real numbers that ends with 99X, by converting it to string, cutting off last digit, then adding extra nines and casting it on number again
// e.g. 2.0199999999999996: +('2.019999999999999' + '9999') will give 2.02
if (stringValue.length >= 17 && afterPoint.length > 2 && +afterPoint.substr(afterPoint.length - 3) > 995) {
stringValue = String(+(stringValue.substr(0, afterPoint.length - 1) + '9'.repeat(stringValue.split('.').shift().length + 4)));
[ beforePoint, afterPoint ] = String(stringValue).indexOf('.') > -1 ? stringValue.split('.') : [ stringValue, ''];
}


if (precision === 0) {
return beforePoint;
} else if (afterPoint.length > precision) {
return `${beforePoint}.${afterPoint.substr(0, precision)}`;
} else {
return `${beforePoint}.${afterPoint}${'0'.repeat(precision - afterPoint.length)}`;
}
}

请记住，精度可能无法正确处理长度为18或更大的数字，例如64位Chrome将四舍五入或添加“e+”/“e-”以保持数字的长度为18。

如果你想对实数执行操作，更安全的做法是先将其乘以Math.sqrt(10, precision)，然后进行计算，然后将结果乘以乘数的值。

例子:

0.06 + 0.01是0.06999999999999999，每个格式化函数如果不是四舍五入，将截断它为0.06，以实现精度2.

但是如果你用乘数除法器(0.06 * 100 + 0.01 * 100) / 100执行同样的操作，你会得到0.07。

这就是为什么在javascript中处理实数时使用乘数/除法是如此重要，特别是当你计算金钱时…

小开

我的解决方案在typescript(可以很容易地移植到JS):

/**
* Returns the price with correct precision as a string
*
* @param   price The price in decimal to be formatted.
* @param   decimalPlaces The number of decimal places to use
* @return  string The price in Decimal formatting.
*/
type toDecimal = (price: number, decimalPlaces?: number) => string;
const toDecimalOdds: toDecimal = (
price: number,
decimalPlaces: number = 2,
): string => {
const priceString: string = price.toString();
const pointIndex: number = priceString.indexOf('.');


// Return the integer part if decimalPlaces is 0
if (decimalPlaces === 0) {
return priceString.substr(0, pointIndex);
}


// Return value with 0s appended after decimal if the price is an integer
if (pointIndex === -1) {
const padZeroString: string = '0'.repeat(decimalPlaces);


return `${priceString}.${padZeroString}`;
}


// If numbers after decimal are less than decimalPlaces, append with 0s
const padZeroLen: number = priceString.length - pointIndex - 1;
if (padZeroLen > 0 && padZeroLen < decimalPlaces) {
const padZeroString: string = '0'.repeat(padZeroLen);


return `${priceString}${padZeroString}`;
}


return priceString.substr(0, pointIndex + decimalPlaces + 1);
};

测试用例:

  expect(filters.toDecimalOdds(3.14159)).toBe('3.14');
expect(filters.toDecimalOdds(3.14159, 2)).toBe('3.14');
expect(filters.toDecimalOdds(3.14159, 0)).toBe('3');
expect(filters.toDecimalOdds(3.14159, 10)).toBe('3.1415900000');
expect(filters.toDecimalOdds(8.2)).toBe('8.20');

任何改善吗?

小开

另一个解决方案，截断和轮:

function round (number, decimals, truncate) {
if (truncate) {
number = number.toFixed(decimals + 1);
return parseFloat(number.slice(0, -1));
}


var n = Math.pow(10.0, decimals);
return Math.round(number * n) / n;
};

小开

这并不是一个安全的替代方法，因为许多其他的例子都将数字转换为指数符号，这个函数没有覆盖这个场景

// typescript
// function formatLimitDecimals(value: number, decimals: number): number {


function formatLimitDecimals(value, decimals) {
const stringValue = value.toString();
if(stringValue.includes('e')) {
// TODO: remove exponential notation
throw 'invald number';
} else {
const [integerPart, decimalPart] = stringValue.split('.');
if(decimalPart) {
return +[integerPart, decimalPart.slice(0, decimals)].join('.')
} else {
return integerPart;
}
}
}


console.log(formatLimitDecimals(4.156, 2)); // 4.15
console.log(formatLimitDecimals(4.156, 8)); // 4.156
console.log(formatLimitDecimals(4.156, 0)); // 4
console.log(formatLimitDecimals(0, 4)); // 0


// not covered
console.log(formatLimitDecimals(0.000000199, 2)); // 0.00

小开

综合前面所有答案的知识，

这就是我想到的解决办法:

function toFixedWithoutRounding(num, fractionDigits) {
if ((num > 0 && num < 0.000001) || (num < 0 && num > -0.000001)) {
// HACK: below this js starts to turn numbers into exponential form like 1e-7.
// This gives wrong results so we are just changing the original number to 0 here
// as we don't need such small numbers anyway.
num = 0;
}
const re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fractionDigits || -1) + '})?');
return Number(num.toString().match(re)[0]).toFixed(fractionDigits);
}

小开

const toFixed = (value) => value.toString().slice(0,5);

小开

function toFixed(num, fixed) {
fixed = fixed || 0;
var front = Math.floor(num);
var back = 0;
for (var i = 1; i <= fixed; i++) {
var value = Math.floor(num * Math.pow(10, i)) % 10;
back += value / Math.pow(10, i);
}
return front + back;
}

小开

如果你想精确地截断为2位精度，你可以使用一个简单的逻辑:

function myFunction(number) {
var roundedNumber = number.toFixed(2);
if (roundedNumber > number)
{
roundedNumber = roundedNumber - 0.01;
}
return roundedNumber;
}

小开

2021年6月更新

这将固定任何给定长度的数字而不舍入

let FixWithoutRounding = (v, l) => {
const intPart = Math.trunc(v).toString()
const fractionPart = v.toString().slice(v.toString().indexOf('.') + 1)
if (fractionPart.length > l) {
return Number(intPart.concat('.', fractionPart.slice(0, l)))
} else {
const padded = intPart.concat('.', fractionPart.padEnd(l, '0'))
return padded
}
}


console.log(FixWithoutRounding(123.123, 12))

小开

一个简单的解决方案

const toFixedNoRounding = (value, digits) => {
const factor = Math.pow(10, digits);


return Math.trunc(value * factor) / factor;
};

小开

为了合作，我必须使用比特币数学运算的解决方案。关键是比特币使用8个十进制数，我们不需要整数。

所以，我这样做了:

做计算;
取值并设置小数点后9位

value = value. tofixed (9);

-去掉最后一个十进制数的子字符串:

value = value.substring(0, value.length - 1);

不。这并不优雅，但它是一个解决方案。

小开

我也面临着同样的问题，并决定在TS中使用字符串操作。

如果没有足够的小数，它将返回原始值

const getDecimalsWithoutRounding = (value: number, numberOfDecimals: number) => {
const stringValue: string = value?.toString();
const dotIdx: number = stringValue?.indexOf('.');
if (dotIdx) {
return parseFloat(stringValue.slice(0, dotIdx + numberOfDecimals + 1));
} else {
return value;
}
};


console.log(getDecimalsWithoutRounding(3.34589, 2)); /// 3.34
console.log(getDecimalsWithoutRounding(null, 2));  ///null
console.log(getDecimalsWithoutRounding(55.123456789, 5)); /// 55.12345
console.log(getDecimalsWithoutRounding(10, 2));  /// 10
console.log(getDecimalsWithoutRounding(10.6, 5)); /// 10.6

小开

一个衬套

const formatPriceWithDecimal = (price: number) =>
parseInt(price * 10000)/10000).toFixed(2)

小开

function FixWithoutRounding(number, digits) {
var gbZero = '0000000000';
var subNumber = number.toString().split('.');


if (subNumber.length === 1)
return [subNumber[0], '.', '0000'].join('');


var result = '';
if (subNumber[1].length > digits) {
result = subNumber[1].substring(0, digits);
} else {
result = subNumber[1] + gbZero.substring(0, digits - subNumber[1].length);
}


return [subNumber[0], '.', result].join('');


}

小开

function limitDecimalsWithoutRounding(val, decimals){
let parts = val.toString().split(".");
return parseFloat(parts[0] + "." + parts[1].substring(0, decimals));
}


var num = parseFloat(15.7784514);
var new_num = limitDecimalsWithoutRounding(num, 2);

将数字截断到小数点后两位而不舍入

2016年11月5日更新

新的答案，总是准确的

老答案，并不总是准确的。

更新(2021年1月)

原答案(2017年10月)