big.js——一个用于任意精度十进制算术的小型快速 JavaScript 库。

特点简单的API比Java的BigDecimal的JavaScript版本更快、更小、更易于使用仅缩小了6KB复制JavaScript数字的toExponential、toFixed和toPrecision方法以可访问的十进制浮点格式存储值全面的文档和测试集没有依赖关系仅使用ECMAScript 3，因此适用于所有浏览器安装该库是单个 JavaScript 文件big.js或 ES 模块big.m

A Rising Girl

9258人浏览 · 2022-02-18 10:49:43

A Rising Girl · 2022-02-18 10:49:43 发布

特点

简单的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