【问题标题】：Truncate number to two decimal places without rounding将数字截断到小数点后两位而不四舍五入
【发布时间】：2011-05-10 09:14:12
【问题描述】：

假设我的值为 15.7784514，我想显示为 15.77，不进行四舍五入。

var num = parseFloat(15.7784514);
document.write(num.toFixed(1)+"<br />");
document.write(num.toFixed(2)+"<br />");
document.write(num.toFixed(3)+"<br />");
document.write(num.toFixed(10));

结果 -

15.8
15.78
15.778
15.7784514000

如何显示 15.77？

【问题讨论】：

我很想问，为什么你不想要四舍五入？无论在哪里，它似乎都不正确......
在显示货币时很有用。
@CamiloMartin 14.9 亿美元的债务和 10 亿美元的债务差距很大。
还有14.9亿美元和15亿美元之间的巨大差异。那是 1 亿美元。
如果您将 $1.49B 的货币四舍五入，您最终可能会告诉某人他们有 $1.5B。他们会在结账时感到失望，并且必须从购物车中移除 $1.5B 的“Eclipse”豪华超级游艇。

标签： javascript

【解决方案1】：

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

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 不同，所以要非常小心。

【讨论】：

+1 这应该可以解决舍入问题。不过，我仍然会使用toFixed 输出上述结果，所以：(Math.floor(value * 100) / 100).toFixed(2)。您可能知道，浮点值可能会发生奇怪的精度问题（另一方面，如果数字恰好是 15，听起来 OP 想要 15.00）。
Math.floor(value * 100) / 100 如果 value = 4.27 真的不行，试试看。
@DarkHippo 那是因为 4.27 实际上是 4.26999999999，Math.round 通常是更好的解决方案，尽管不是原始问题的答案。实际上给出的输出是一个字符串，这应该使用字符串操作而不是具有所有浮点缺点的数字解决方案来完成。
...这听起来不对。在任何情况下类型之间的转换似乎都是迂回和不安全的。除非一个真正高级的程序员会争辩说“所有类型都只是流”之类的。
@AnubhavGupta 要使其在小数点前没有值的情况下工作，只需将正则表达式中的 + 更改为 * 即可：match(/^-?\d*(?:\.\d{0,2})?/)

【解决方案2】：

2016 年 11 月 5 日更新

新答案，始终准确

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

由于floating point math in javascript 总是有边缘情况，以前的解决方案在大多数情况下都是准确的，这还不够好。有一些解决方案，例如num.toPrecision、BigDecimal.js 和accounting.js。然而，我相信仅解析字符串将是最简单且始终准确的。

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

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

滚动你自己的toFixed函数：

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

【讨论】：

toFixed(4.56, 2) = 4.55
这些答案中有很多在 Math.floor() 函数中都有乘法。对于某些数字，这将失败！浮点运算不准确，需要使用不同的方法。
function toFixedCustom(num, fixed) { var re = new RegExp('^-?\\d+(?:\.\\d{0,' + (fixed || -1) + '})?'); if(num.toString().match(re)){ return num.toString().match(re)[0]; } }
对于一个足够大或小到 javascript 可以用科学记数法表示的数字，更新的答案将失败。 toFixed(0.0000000052, 2) 产生“5.2”。这可以通过使用 return num.toFixed(fixed+1).match(re)[0]; 来解决。注意我使用 toFixed 与目标上方一位小数以避免四舍五入，然后运行你的正则表达式匹配
@guya，我很确定 -0.001 会返回 -0.00。我认为在大多数情况下，您会想要不带负号的 0 或 0.00。

【解决方案3】：

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

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;

【讨论】：

如果您不强制使用小数，您可能需要添加条件以防遇到整数。像这样： num = num.toString(); if(num.indexOf(".") > 0){num = num.slice(0, (num.indexOf("."))+3)};数字（数量）；
如果它有小数就很好，但如果它是一个整数就会失败
如果num是0.00000052，那么得到5.2e就错了
@Vasanth 如果数字为 0.00000052，则返回“0.00”。也许答案已经被编辑了
是的，在极端情况下它会失败

【解决方案4】：

另一种单行解决方案：

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

我使用 100 是因为您想截断到第二个数字，但更灵活的解决方案是：

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

digits 是要保留的小数位数。

有关详细信息和浏览器兼容性，请参阅Math.trunc specs。

【讨论】：

如果您不必支持IE11，这是最好的答案。
@T.Junghans 抱歉，这不起作用：(4.27, 2) => 4.26，无论 IE11 或任何其他浏览器如何，都会发生这种情况。

【解决方案5】：

更新（2021 年 1 月）

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

此更新是关于添加一个函数来检查数字是否为科学格式，如果是，则将其转换为十进制格式。在这里我提出这个one，但您可以根据您的应用程序的需要使用任何其他实现相同目标的功能：

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)

【讨论】：

toFixedTrunc(0.000000199, 2) // 1.99
SC1000，我不确定如何解释您对@Maharramoff 的回答。你是说因为有解释为什么你的代码有时会失败，所以代码是正确的？还是说 1.99 是将 0.000000199 截断到小数点后 2 位的正确结果？
@Philippe-AndréLorin 如果问题不清楚，考虑这个函数 concatNumbers (a,b) { return a.toString() + ':' + b.toString() } 并尝试一下带参数 a) (0.000001, 2) b) (0.0000001, 2)。虽然 a) 返回预期结果 ("0.000001:2")，但 b) 不返回 ("1e-7:2")。如您所见，这是一个普遍问题，并非特定于答案中的功能。
@SC1000 你只是在解释你的方法失败的原因。问题是您假设数字只有一种可能的字符串表示形式，并且对于 0.000000199，这种表示形式将是“0.000000199”。如果语言不能保证这一点，那么依赖它就是错误的。
@Maharramoff 和其他对 toFixedTrunc(0.000000199, 2) 案例感兴趣的人，请参阅更新后的答案（2021 年 1 月）。谢谢。

【解决方案6】：

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"

【讨论】：

它以 1234567.89 失败
你能详细说明洛佩兹吗？
floorFigure(4.56, 2) = 4.55

【解决方案7】：

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

这将返回 19.66

【讨论】：

(4.9999).toFixed(3).slice(0, -1) 返回 5.00，预期结果为 4.99。
我建议改用 .toFixed(6).slice(0, -4) 之类的东西。
那是完美的，在我的情况下它可以正常工作。例如，如果我只想有一个十进制数，请使用 num.toFixed(2).slice(0,-1) （如果 num 有 1.2356，它将返回 1.2）

【解决方案8】：

这不是一个安全的选择，因为许多其他人评论的例子中的数字变成了指数符号，这个功能没有涵盖风景

// 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

【讨论】：

【解决方案9】：

我使用以下简单方法进行了修复-

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

结果将是 15.77

【讨论】：

它不适用于负值：-15.7784514 返回-15.78

【解决方案10】：

这样做很简单

number = parseInt(number * 100)/100;

【讨论】：

parseInt(8.2*100) = 819

【解决方案11】：

只需截断数字：

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

【讨论】：

谢谢。当然，您可以将其添加到原型中：Number.prototype.truncDigits = function (digits) { const fact = 10 ** digits; return Math.floor(this.valueOf() * fact) / fact; }。所以你可以把它当作：num.truncDigits(3)

【解决方案12】：

我的正数版本：

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

快速、漂亮、明显。（正数版本）

【讨论】：

需要对浮点值（例如货币）进行非舍入，只有 1 个小数。上面的功能应该是这个话题的“答案”，非常棒，很有魅力。向作者干杯并感谢。 :)))
负值失败。 -0.7752。测试它toFixed_norounding(-0.7752,2) 返回-0.78 而不是-0.77

【解决方案13】：

这些解决方案确实有效，但对我来说似乎不必要地复杂。我个人喜欢使用模运算符来获得除法运算的余数，然后将其删除。假设 num = 15.7784514：

num-=num%.01;

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

【讨论】：

这很有趣Nijkokun，感谢您指出。我从来没有遇到过使用这种技术的问题，但显然我应该仔细看看这样的例子。作为替代方案，您可以使用 ((num*=100)-(num%1))/100 来解决此问题。在我的案例中，优先级是执行速度，因为我应用的计算量很大，这是我发现的最快的实现方式。
关键是要避免提供的其他解决方案中所需的对象和函数查找和转换。感谢您的反馈！
也失败，负数为 -5
我也对快速舍入感兴趣，你如何让这段代码做 1 个小数？
您好，感谢您非常聪明的 solotion。但如果数字比所需的轮数更短，它就不起作用：a = 1.2585; a -= a % .00001; a 现在是1.25849

【解决方案14】：

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

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

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

【讨论】：

Dec2(99) 应该返回 99.00

【解决方案15】：

以下代码对我来说非常有用：

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

【讨论】：

我将添加可选的减号以使其完美-? ;)

【解决方案16】：

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

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>

【讨论】：

【解决方案17】：

下一个简单的方法是确保金额参数以字符串形式给出。

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

【讨论】：

【解决方案18】：

给你。一个答案显示了解决问题的另一种方法：

// 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));
}

注意在最终表达式之前使用 +。也就是将我们截断、切片的字符串转换回数字类型。

希望对你有帮助！

【讨论】：

我喜欢这种方法的简单性，我觉得所有避免使用数学的解决方案都更适合解决这个问题。因此，使用 slice() 等是正确的方法。我的方法的唯一优点是它将处理传入的数字，这些数字是字符串[用引号括起来[单/双]]。出于某种原因，当我这样做时，上面的函数在 FF 中引发了错误：console.log('truncate("0.85156",2)',truncate("0.85156",2));

【解决方案19】：

不带零的截断

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

【讨论】：

【解决方案20】：

如果您确实想截断为 2 位精度，您可以使用简单的逻辑：

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

【讨论】：

这会导致减法问题并产生不正确的结果。
OP 给出了正浮点数而不是整数的情况。当从浮点数中减去 0.01 时，Javascript 不会给出正确的结果。例如，如果您在浏览器控制台中运行 2.37 - 0.01，您将得到的答案将是 2.3600000000000003

【解决方案21】：

我使用(num-0.05).toFixed(1) 得到第二个小数点。

【讨论】：

【解决方案22】：

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

Reference Answer

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

谢谢！

【讨论】：

【解决方案23】：

我在 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');

有什么改进吗？

【讨论】：

【解决方案24】：

滚动您自己的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。

例如，

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

【讨论】：

这么多答案在 Math.floor() 函数中都有乘法。对于某些数字，这将失败！浮点运算不准确，需要使用不同的方法。

【解决方案25】：

Gumbo 使用正则表达式的第二个解决方案确实有效，但由于正则表达式而运行缓慢。由于浮点数不精确，Gumbo 的第一个解决方案在某些情况下会失败。有关演示和基准，请参阅 JSFiddle。第二种解决方案在我当前的系统（3.30 GHz 的 Intel Core i5-2500 CPU）上每次调用大约需要 1636 纳秒。

我编写的解决方案涉及添加一个小的补偿来处理浮点不精确性。它基本上是瞬时的，即纳秒级。我每次调用计时 2 纳秒，但 JavaScript 计时器不是非常精确或精细。这是JS Fiddle 和代码。

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);

【讨论】：

【解决方案26】：

以 David 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

【讨论】：

【解决方案27】：

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

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

【讨论】：

【解决方案28】：

这是用字符串做了什么

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;
}

【讨论】：

【解决方案29】：

所有这些答案似乎都有些复杂。我会从你的数字中减去 0.5 并使用 toFixed()。

【讨论】：

你的意思是 0.005？

【解决方案30】：

另一种解决方案，截断和round：

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;
};

【讨论】：