在javascript中四舍五入到任意数量的有效数字不起作用

Question

我试过下面的示例代码

function sigFigs(n, sig) {
    if ( n === 0 )
        return 0
    var mult = Math.pow(10,
        sig - Math.floor(Math.log(n < 0 ? -n: n) / Math.LN10) - 1);
    return Math.round(n * mult) / mult;
 }

但是这个函数不适用于像 sigFigs(24730790,3) 返回 24699999.999999996 和 sigFigs(4.7152e-26,3) 返回：4.7200000000000004e-26 这样的输入

如果有人有工作示例，请分享。 谢谢。

Answer 1

您可以尝试使用 javascript 内置方法-

Number( my_number.toPrecision(3) )

对于你的情况试试

Number( 24730790.0.toPrecision(5) )

对于您的参考和工作示例，您可以查看链接

Answer 2

首先感谢大家，如果没有共享这些片段，这将是一项艰巨的任务。

我的附加值是以下代码段（完整实现见下文）

parseFloat(number.toPrecision(precision))

请注意，例如，如果 number 为 10000 且精度为 2，则number.toPrecision(precision)将为 '1.0e+4' 但parseFloat理解指数表示法。

还值得一提的是，不管你信不信，上面发布的使用Math.pow和对数的算法在测试用例formatNumber(5, 123456789)上运行时在 Mac（节点 v12）上获得成功，但在Windows（节点 v10）。 这很奇怪，所以我们得出了上面的解决方案。

最后，我发现这是最终的实现，利用了这篇文章中提供的所有反馈。 假设我们有一个包含以下内容的formatNumber.js文件

/**
 * Format number to significant digits.
 *
 * @param {Number} precision
 * @param {Number} number
 *
 * @return {String} formattedValue
 */

export default function formatNumber (precision, number) {
  if (typeof number === 'undefined' || number === null) return ''

  if (number === 0) return '0'

  const roundedValue = round(precision, number)
  const floorValue = Math.floor(roundedValue)

  const isInteger = Math.abs(floorValue - roundedValue) < Number.EPSILON

  const numberOfFloorDigits = String(floorValue).length
  const numberOfDigits = String(roundedValue).length

  if (numberOfFloorDigits > precision) {
    return String(floorValue)
  } else {
    const padding = isInteger ? precision - numberOfFloorDigits : precision - numberOfDigits + 1

    if (padding > 0) {
      if (isInteger) {
        return `${String(floorValue)}.${'0'.repeat(padding)}`
      } else {
        return `${String(roundedValue)}${'0'.repeat(padding)}`
      }
    } else {
      return String(roundedValue)
    }
  }
}

function round (precision, number) {
  return parseFloat(number.toPrecision(precision))
}

如果您使用胶带进行测试，这里有一些基本测试

import test from 'tape'

import formatNumber from '..path/to/formatNumber.js'

test('formatNumber', (t) => {
  t.equal(formatNumber(4, undefined), '', 'undefined number returns an empty string')
  t.equal(formatNumber(4, null), '', 'null number return an empty string')

  t.equal(formatNumber(4, 0), '0')
  t.equal(formatNumber(4, 1.23456789), '1.235')
  t.equal(formatNumber(4, 1.23), '1.230')
  t.equal(formatNumber(4, 123456789), '123500000')
  t.equal(formatNumber(4, 1234567.890123), '1235000')
  t.equal(formatNumber(4, 123.4567890123), '123.5')
  t.equal(formatNumber(4, 12), '12.00')
  t.equal(formatNumber(4, 1.2), '1.200')
  t.equal(formatNumber(4, 1.234567890123), '1.235')
  t.equal(formatNumber(4, 0.001234567890), '0.001235')

  t.equal(formatNumber(5, 123456789), '123460000')

  t.end()
})

Answer 3

不幸的是，当数字 > 10 时，内置方法会给你愚蠢的结果，比如指数符号等。

我做了一个函数，它应该可以解决这个问题（也许不是最优雅的编写方式，但它在这里）：

function(value, precision) {
  if (value < 10) {
    value = parseFloat(value).toPrecision(precision)
  } else {
    value = parseInt(value)
    let significantValue = value
    for (let i = value.toString().length; i > precision; i--) {
      significantValue = Math.round(significantValue / 10)
    }
    for (let i = 0; significantValue.toString().length < value.toString().length; i++ ) {
      significantValue = significantValue * 10
    }
    value = significantValue
  }
  return value
}

如果您更喜欢对更高的数字使用指数表示法，请随意使用 toPrecision() 方法。

Answer 4

自动类型转换如何处理指数表示法？

f = (x, n) => +x.toPrecision(n)

测试：

> f (0.123456789, 6)
0.123457
> f (123456789, 6)
123457000
> f (-123456789, 6)
-123457000
> f (-0.123456789, 6)
-0.123457
> f (-0.123456789, 2)
-0.12
> f (123456789, 2)
120000000

它返回一个数字而不是一个字符串。

Answer 5

如果要指定小数点左边的有效数字并分别用 TBMK 替换无关的占位符

// example to 3 sigDigs (significant digits)
//54321 = 54.3M
//12300000 = 12.3M

const moneyFormat = (num, sigDigs) => {
   var s = num.toString();
   let nn = "";
   for (let i = 0; i <= s.length; i++) {
      if (s[i] !== undefined) {
         if (i < sigDigs) nn += s[i];
         else nn += "0";
      }
   }
   nn = nn
      .toString()
      .replace(/(\d)(?=(\d\d\d)+(?!\d))/g, "$1,")
      .replace(",000,000,000", "B")
      .replace(",000,000", "M")
      .replace(",000", "k");
   if (
      nn[nn.length - 4] === "," &&
      nn[nn.length - 2] === "0" &&
      nn[nn.length - 1] === "0"
   ) {
      let numLetter = "K";
      if (parseInt(num) > 999999999999) numLetter = "T";
      else if (parseInt(num) > 999999999) numLetter = "B";
      else if (parseInt(num) > 999999) numLetter = "M";
      console.log("numLetter: " + numLetter);
      nn = nn.toString();
      let nn2 = ""; // new number 2
      for (let i = 0; i < nn.length - 4; i++) {
         nn2 += nn[i];
      }
      nn2 += "." + nn[nn.length - 3] + numLetter;
      nn = nn2;
   }

   return nn;
};