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

我尝试了下面的示例代码

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

函数信号图（n，信号）{
如果（n==0）
返回0
var mult=数学功率（10，
sig-数学层（数学日志（n<0？-n:n）/Math.LN10）-1）；
返回数学圆（n*mult）/mult；
}

但该函数不适用于以下输入： sigifigs（24730790,3）返回2469999.99999996 和SIGIFIGS（4.7152e-26,3）返回：4.7200000000000004e-26

如果任何人有工作的例子，请分享。

---

谢谢。

您可以尝试javascript内置方法-

Number( my_number.toPrecision(3) )

你的情况试试看

Number( 24730790.0.toPrecision(5) )

---

对于您的参考和工作示例，您可以看到

不幸的是，当数字大于10时，内置方法会给出愚蠢的结果，如指数表示法等

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

函数（值、精度）{
如果（值<10）{
value=parseFloat（值）。toPrecision（精度）
}否则{
value=parseInt（值）
设有效值=有效值
for（设i=value.toString（）.length；i>precision；i--）{
有效值=数学四舍五入（有效值/10）
}
for（设i=0；有效值.toString（）.length

---

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

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

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

请注意，例如，如果数字为10000，精度为2，则

number。toPrecision（precision）

将为“1.0e+4”，但

parseFloat

理解指数表示法

同样值得一提的是，信不信由你，当在测试用例

formatNumber（5123456789）

上运行时，使用

Math.pow

和上面发布的对数的算法在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))
}

---

自动类型转换如何，它负责指数表示法

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

---

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

如果要指定小数点后的有效数字，并分别用tb M K替换多余的占位符

//示例到3个sigdig（有效数字）
//54321=54.3M
//12300000=12.3M
const moneyFormat=（num，sigDigs）=>{
var s=num.toString（）；
设nn=“”；
对于（设i=0；i 9999999999）numLetter=“T”；
如果（parseInt（num）>99999999）numLetter=“B”；
如果（parseInt（num）>999999）numLetter=“M”；
log（“numLetter:+numLetter”）；
nn=nn.toString（）；
设nn2=“；//新编号2
for（设i=0；i

我尝试在

（123456，3）

上使用你的函数，它给了我

124000

而不是

123000

。也许单位的四舍五入会一直延续到几百。谢谢，这很好。节省了我不少工作。

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()
})

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