特点

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