big.js——一个用于任意精度十进制算术的小型快速 JavaScript 库。
特点
简单的API
比Java的BigDecimal的JavaScript版本更快、更小、更易于使用
仅缩小了6KB
复制JavaScript数字的toExponential、toFixed和toPrecision方法
以可访问的十进制浮点格式存储值
全面的文档和测试集
没有依赖关系
仅使用ECMAScript 3，因此适用于所有浏览器
安装
该库是单个 JavaScript 文件big.js或 ES 模块big.mjs。
Browsers
将 Big 添加到全局范围：
< script src =' path/to/big.js ' > </ script >
ES模块：
<script type='module'>
import Big from './path/to/big.mjs';
从 CDN 获取缩小版本：
< script src =' https://cdn.jsdelivr.net/npm/big.js@6.0.0/big.min.js ' > </ script >
Node.js
$ npm install big.js
CommonJS:
const Big = require('big.js');
ES module:
import Big from 'big.js';
Deno
import Big from 'https://raw.githubusercontent.com/mikemcl/big.js/v6.0.0/big.mjs';
import Big from 'https://unpkg.com/big.js@6.0.0/big.mjs';
属性
DP
number : 整数，0 到 1e+6 （含）
默认值：20
除法运算结果的最大小数位数。
它仅与div和sqrt方法有关，以及pow指数为负时的方法。
调用上述方法之一时，将检查该值的有效性。
如果发现该值无效，将引发错误。
Big.DP = 40
RM
数字：0、1、2 或 3
默认值：1
在涉及除法和 除以round、 toExponential和 的运算中使用的舍入模式 。 toFixedtoPrecision
调用上述方法之一时，将检查该值的有效性。
如果发现该值无效，将引发错误。
Big.RM = 0
Big.RM = Big.roundUp
NE
number：整数，-1e+6 到 0 （含）
默认值：-7
负指数值等于或低于它 toString返回指数符号。
Big.NE = -7
x = new Big(0.00000123) // '0.00000123' e is -6
x = new Big(0.000000123) // '1.23e-7'
JavaScript 数字使用指数表示法来表示 -7及以下的负指数。
无论 的值如何Big.NE，该 toFixed方法将始终以正常表示法返回一个值，并且该toExponential 方法将始终以指数形式返回一个值。
PE
number : 整数，0 到 1e+6 （含）
默认值：21
toString大于等于返回指数符号 的正指数值 。
Big.PE = 2
x = new Big(12.3) // '12.3' e is 1
x = new Big(123) // '1.23e+2'
JavaScript 数字使用指数表示法来表示 21及以上的正指数。
无论 的值如何Big.PE，该 toFixed方法将始终以正常表示法返回一个值，并且该toExponential 方法将始终以指数形式返回一个值。
strict
true|false
默认值：false
当设置为true时，如果将原始数传递给Big构造函数，或者如果调用valueOf，或者如果对无法转换为基元数而不损失精度的大函数调用toNumber，则会引发错误。
Big.strict = true
x = new Big(1) // ‘TypeError: [big.js] String expected’
y = new Big(‘1.000000000000000000001’)
2 + y // ‘Error: [big.js] valueOf disallowed’
y.toNumber() // ‘Error: [big.js] Imprecise conversion’
Big.strict = false
x = new Big(0.1)
y = new Big('1.000000000000000000001')
2 + y // '21.000000000000000000001'
y.toNumber() // 1
方法
Big number 实例从其构造函数的原型对象继承的方法。
Big number 是不可变的，因为它不会被它的方法改变。
abs .abs() ⇒ Big
返回一个 Big 数字，其值为该 Big 数字的绝对值，即大小。
x = new Big(-0.8)
x.abs() // '0.8'
cmp .cmp(n) ⇒ number
n : number|string|Big
Returns
1 如果这个大数的值大于 n
-1 如果这个大数的值小于 n
0 如果这个大数字和n具有相同的值
n如果无效则抛出。
x = new Big(6)
y = new Big(5)
x.cmp(y) // 1
y.cmp(x.minus(1)) // 0
返回一个 Big 数字，其值为该 Big 数字除以 的值n。
div .div(n) ⇒ Big
n : number|string|Big
如果结果的小数位数比 指定的多 Big.DP，则将 Big.DP使用舍入模式将其舍入到小数位 Big.RM。
n如果为零或其他无效则抛出。
x = new Big(355)
y = new Big(113)
x.div(y) // '3.14159292035398230088'
Big.DP = 2
x.div(y) // '3.14'
x.div(5) // '71'
eq .eq(n) ⇒ boolean
n : number|string|Big
如果此 Big number 的值等于n，则返回true，否则返回false。
n如果无效则抛出。
0 === 1e-324 // true
x = new Big(0)
x.eq('1e-324') // false
Big(-0).eq(x) // true ( -0 === 0 )
gt. gt(n) ⇒ boolean
n : number|string|Big
如果此 Big 数字的值大于n 的值，则 返回true，否则返回false。
n如果无效则抛出。
0.1 > 0.3 - 0.2 // true
x = new Big(0.1)
x.gt(Big(0.3).minus(0.2)) // false
Big(0).gt(x) // false
gte .gte(n) ⇒ boolean
n : number|string|Big
如果此 Big 数字的值大于或等于n 的值，则 返回true，否则返回false。
0.3 - 0.2 >= 0.1 // false
x = new Big(0.3).minus(0.2)
x.gte(0.1) // true
Big(1).gte(x) // true
lt .lt(n) ⇒ boolean
n : number|string|Big
如果此 Big number 的值小于n的值，则返回true，否则返回false。
n如果无效则抛出。
0.3 - 0.2 < 0.1 // true
x = new Big(0.3).minus(0.2)
x.lt(0.1) // false
Big(0).lt(x) // true
minus .minus(n) ⇒ Big
n : number|string|Big
返回一个 Big 数字，其值为该 Big 数字减去n的值。
n如果无效则抛出。
0.3 - 0.1 // 0.19999999999999998
x = new Big(0.3)
x.minus(0.1) // '0.2'
mod .mod(n) ⇒ Big
n : number|string|Big
返回一个 Big 数字，其值是这个 Big 数字的模值 n，即这个 Big 数字除以的整数余数 n。
结果将与这个 Big 数字具有相同的符号，并且它将匹配 JavaScript 的 % 运算符（在其精度范围内）和 BigDecimal 的余数方法。
n如果为零或其他无效则抛出。
1 % 0.9 // 0.09999999999999998
x = new Big(1)
x.mod(0.9) // '0.1'
plus .plus(n) ⇒ Big
n : number|string|Big
返回一个 Big 数字，其值为该 Big 数字加 n 的值。
n如果无效则抛出。
0.1 + 0.2 // 0.30000000000000004
x = new Big(0.1)
y = x.plus(0.2) // '0.3'
Big(0.7).plus(x).plus(y) // '1.1'
pow .pow(n) ⇒ Big
n : number : integer, 包括-1e+6 到 1e+6
返回一个 Big 数字，其值是这个 Big 数字的幂的值n。
这里，n必须是 JavaScript 数字，而不是大数字，因为只允许小整数。
如果n为负数且结果的小数位数多于 指定的位数Big.DP，则将Big.DP使用舍入模式舍入到小数位Big.RM。
n如果无效 则抛出。
注意：高值指数可能会导致此方法返回缓慢。
Math.pow(0.7, 2) // 0.48999999999999994
x = new Big(0.7)
x.pow(2) // ‘0.49’
Big.DP = 20
Big(3).pow(-2) // ‘0.11111111111111111111’
new Big(123.456).pow(1000).toString().length // 5099
new Big(2).pow(1e+6) // Time taken (Node.js): 9 minutes 34 secs.
prec .prec(sd, rm)⇒ Big
sd? : number : integer, 1 to 1e+6 inclusive
rm? : number : 0, 1, 2 or 3
返回一个 Big 数字，其值是sd使用舍入模式舍入到有效数字 的最大精度的此 Big 数字的值rm，或者Big.RM如果rm省略或未定义。
sd如果或rm无效 则抛出。
down = 0
half_up = 1
x = new Big('9876.54321')
x.prec(2) // '9900'
x.prec(7) // '9876.543'
x.prec(20) // '9876.54321'
x.prec(1, down) // '9000'
x.prec(1, half_up) // '10000'
x // '9876.54321'
round .round(dp, rm) ⇒ Big
dp? : number : integer, -1e+6 to 1e+6 inclusive
rm? : number : 0, 1, 2 or 3
返回一个大数字，其值是使用舍入模式rm舍入的该大数字的值，最大小数位数为dp，如果dp为负数，则返回一个整数，该整数是10**-dp的倍数。
如果省略或未定义dp，则返回值是这个大数字的值，四舍五入为整数。
如果rm被省略或未定义，则当前值较大。使用RM设置。
如果dp或rm无效，则抛出
x = 123.45
Math.round(x) // 123
y = new Big(x)
y.round() // '123'
y.round(2) // '123.45'
y.round(10) // '123.45'
y.round(1, Big.roundDown) // '123.4'
y.round(1, Big.roundHalfUp) // '123.5'
y.round(1, Big.roundHalfEven) // '123.4'
y.round(1, Big.roundUp) // '123.5'
y.round(-1, Big.roundDown) // '120'
y.round(-2, Big.roundUp) // '200'
y // '123.45'
sqrt .sqrt() ⇒ Big
返回一个Big数，其值为该Big数的平方根。
如果结果的小数位数比 指定的多 Big.DP，则将 Big.DP使用舍入模式将其舍入到小数位 Big.RM。
如果这个大数字是负数，则抛出。
x = new Big(16)
x.sqrt() // '4'
y = new Big(3)
y.sqrt() // '1.73205080756887729353'
times .times(n) ⇒ Big
n : number|string|Big
返回一个 Big 数字，其值为此 Big number 乘以的值 n。
n如果无效则抛出。
0.6 * 3 // 1.7999999999999998
x = new Big(0.6)
y = x.times(3) // '1.8'
Big('7e+500').times(y) // '1.26e+501'
toExponential .toExponential(dp, rm) ⇒ string
dp? : number : integer,包括 0 到 1e+6
rm? : number : 0, 1, 2 or 3
以指数表示法返回一个字符串，该字符串表示此 Big 数字的值，并保留固定的dp小数位数。
如果这个大数的指数表示法的小数点右边的位数比指定的多dp，则返回值将dp使用舍入模式四舍五入到小数位rm。
如果这个大数的指数表示法中小数点右边的位数少于 指定的位数dp，则返回值将相应地附加零。
如果dp省略或未定义，则小数点后的位数默认为准确表示该值所需的最小位数。
如果rm省略或未定义， Big.RM则使用当前设置。
dp如果或rm无效 则抛出。
x = 45.6
y = new Big(x)
x.toExponential() // '4.56e+1'
y.toExponential() // '4.56e+1'
x.toExponential(0) // '5e+1'
y.toExponential(0) // '5e+1'
x.toExponential(1) // '4.6e+1'
y.toExponential(1) // '4.6e+1'
y.toExponential(1, Big.roundDown) // '4.5e+1'
x.toExponential(3) // '4.560e+1'
y.toExponential(3) // '4.560e+1'
toFixed .toFixed(dp, rm) ⇒ string
dp? : number : integer, 0 to 1e+6 inclusive
rm? : number : 0, 1, 2 or 3
dp以固定的小数位数 返回一个字符串，该字符串以正常表示法表示此 Big 数字的值。
如果这个Big数字在正常表示法中的小数点右边的位数比指定的多dp，则返回值将dp使用四舍五入模式四舍五入到小数位rm。
如果这个Big数字在正常表示法中的小数位数较少，则由 指定dp，则返回值将相应地附加零。
与Number.prototype.toFixed如果数字大于或等于 10 21返回指数符号不同，此方法将始终返回正常符号。
如果dp省略或未定义，则返回值只是普通表示法中的值。这也与 不同 Number.prototype.toFixed，后者将值返回到零小数位。
如果rm省略或未定义， Big.RM则使用当前设置。
dp如果或rm无效 则抛出。
x = 45.6
y = new Big(x)
x.toFixed() // '46'
y.toFixed() // '45.6'
y.toFixed(0) // '46'
x.toFixed(3) // ' 45.600'
y.toFixed(3) // '45.600'
toJSON .toJSON() ⇒ string
和toString一样.
x = new Big('177.7e+457')
y = new Big(235.4325)
z = new Big('0.0098074')
str = JSON.stringify( [x, y, z] )
JSON.parse(str, function (k, v) { return k === '' ? v : new Big(v) })
// Returns an array of three Big numbers.
toPrecision .toPrecision(sd, rm) ⇒ string
sd? : number : integer, 包括1 到 1e+6
rm? : number : 0, 1, 2 or 3
返回一个字符串，该字符串表示此 Big 数字的值到指定的sd有效数字位数。
如果这个 Big number 的值的位数多于 指定的位数 sd，则返回值将sd 使用舍入模式舍入到有效位数 rm。
如果此 Big 数字的值的位数少于 指定的位数 sd，则返回值将相应地附加零。
如果sd小于以正常表示法表示值的整数部分所需的位数，则使用指数表示法。
如果sd省略或未定义，则返回值与 相同.toString()。
如果rm省略或未定义， Big.RM则使用当前设置。
sd如果或rm无效 则抛出。
x = 45.6
y = new Big(x)
x.toPrecision() // '45.6'
y.toPrecision() // '45.6'
x.toPrecision(1) // '5e+1'
y.toPrecision(1) / / '5e+1'
x.toPrecision(5) // '45.600'
y.toPrecision(5) // '45.600'
toNumber .toNumber() ⇒ number
返回表示此Big数字值的原始数字。
x = new Big('123.45')
x.toNumber() // 123.45
y = new Big('1.0000000000000000001')
y.toNumber() // 1
Big.strictis = true如果在Big数上调用，将抛出错误toNumber，该Big数不能在不损失精度的情况下转换为原始数。
toString .toString() ⇒ string
返回表示此大数字值的字符串。
如果这个大数的正指数等于或大于 21，或者负指数等于或小于 -7，则返回指数表示法。
toString可以通过更改 和 的值来调整返回指数而不是正常表示法 Big.PE的 点Big.NE。默认情况下，大数字在这方面对应于 JavaScript 的数字类型。
x = new Big('9.99e+20')
x.toString() // '999000000000000000000'
y = new Big('1E21')
y.toString() // '1e+21'
valueOf .valueOf() ⇒ string
因为toString除了负零包含减号。
x = new Big(-0)
x.valueOf() // '-0'
x.toString() // '0'
为了防止在算术运算符中意外使用大数，strict为true任何对valueOf的显式或隐式调用都将导致错误。
使用
toString在下面的代码示例中，没有显示分号和调用。
该库导出单个构造函数，Big.
Big数字是从原始数字、字符串或其他Big数字创建的。
x = new Big(123.4567)
y = Big('123456.7e-3') // 'new' is optional
z = new Big(x)
x.eq(y) && x.eq(z) && y.eq(z) // true
在 Big严格模式下，不允许从原始数字创建大数字。
Big.strict = true
x = new Big(1) // TypeError: [big.js] Invalid number
y = new Big('1.0000000000000001')
y.toNumber() // Error: [big.js] Imprecise conversion
Big 数字不会被它的方法改变。
0.3 - 0.1 // 0.19999999999999998
x = new Big(0.3)
x.minus(0.1) // "0.2"
x // "0.3"
返回Big数字的方法可以连接起来。
x.div(y).plus(z).times(9).minus('1.234567801234567e+8').plus(976.54321).div('2598.11772')
x.sqrt().div(y).pow(3).gt(y.mod(z)) // true
像 JavaScript 的 Number 类型一样，有toExponential,toFixed和toPrecision方法
x = new Big(255.5)
x.toExponential(5) // "2.55500e+2"
x.toFixed(5) // "255.50000"
x.toPrecision(5) // "255.50"
算术方法总是返回除div、sqrt和pow（负指数）之外的精确结果，因为这些方法涉及除法。
用于对这些方法的结果进行舍入的最大小数位数和舍入模式由Big数构造函数的DP和RM属性值决定。
Big.DP = 10
Big.RM = Big.roundHalfUp
x = new Big(2);
y = new Big(3);
z = x.div(y) // "0.6666666667"
z.sqrt() // "0.8164965809"
z.pow(-3) // "3.3749999995"
z.times(z) // "0.44444444448888888889"
z.times(z).round(10) // "0.4444444445"
Big数字的值以十进制浮点格式存储，以系数、指数和符号表示。
x = new Big(-123.456);
x.c // [1,2,3,4,5,6] coefficient (i.e. significand)
x.e // 2 exponent
x.s // -1 sign
对于高级使用，可以创建多个大数量构造函数，每个构造函数都有一个独立的配置。
有关更多信息，请参阅API参考文档。
缩小
例如使用 npm 和terser进行最小化
$ npm install -g terser
$ terser big.js -c -m -o big.min.js
测试目录包含每个大数字方法的测试脚本。
可以使用 Node.js 或浏览器运行测试。
运行所有测试：
$ npm test
测试单个方法：
$ node test/toFixed
对于浏览器，请参见test/browser目录中的runner.html和test.html 。
big-vs-number.html是一个旧应用程序，它可以将 big.js 的一些方法与 JavaScript 的 Number 类型的方法进行比较。
TypeScript：
DefinitiveTyped 项目有一个用于 big.js的Typescript类型定义文件。
有关 TypeScript 类型定义文件的任何问题都可以提交给DefinitelyTyped 项目。
官方文档：https://mikemcl.github.io/big.js/
https://mikemcl.github.io/big.js/#dp
旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。
更多推荐
3
0- 0
已为社区贡献1条内容
所有评论(0)