Una biblioteca de JavaScript para aritmética decimal y no decimal de precisión arbitraria
Dirección: https://github.com/MikeMcl/bignumber.js
Características
- Enteros y decimales
- API simple, pero con todas las funciones
- Más rápido, más pequeño y posiblemente más fácil de usar que la versión JavaScript de BigDecimal de Java
- Solo 8 KB de tamaño
- Admite generación de números pseudoaleatorios de seguridad de contraseña
- Sin dependencia
- Amplia compatibilidad de plataforma: solo use las funciones de JavaScript 1.5 (ECMAScript 3)
Navegador:
<script src = 'ruta / a / bignumber.js'> </script>
Node.js
$ npm install bignumber.js
const BigNumber = require('bignumber.js');
import BigNumber from "bignumber.js";
// or
import { BigNumber } from "bignumber.js";usar
Un solo constructor BigNumber, que acepta un valor de tipo Number, String o BigNumber,
let x = new BigNumber(123.4567);
let y = BigNumber('123456.7e-3');
let z = new BigNumber(x);
x.isEqualTo(y) && y.isEqualTo(z) && x.isEqualTo(z); // true
Para obtener el valor de cadena de BigNumber, puede usar toString () o toFixed (). El uso de toFixed () puede evitar volver a la notación exponencial, sin importar cuán grande o pequeño sea el valor.
let x = new BigNumber('1111222233334444555566');
x.toString(); // "1.111222233334444555566e+21"
x.toFixed(); // "1111222233334444555566"
Si no comprende bien la precisión limitada de los valores numéricos, se recomienda crear números grandes a partir de valores de cadena en lugar de valores numéricos para evitar una posible pérdida de precisión.
En todos los ejemplos siguientes, no se muestran los puntos y comas ni las llamadas a toString. Si el valor comentado está entre comillas, significa que se llamó a toString en la expresión anterior.
// Precision loss from using numeric literals with more than 15 significant digits.
new BigNumber(1.0000000000000001) // '1'
new BigNumber(88259496234518.57) // '88259496234518.56'
new BigNumber(99999999999999999999) // '100000000000000000000'
// Precision loss from using numeric literals outside the range of Number values.
new BigNumber(2e+308) // 'Infinity'
new BigNumber(1e-324) // '0'
// Precision loss from the unexpected result of arithmetic with Number values.
new BigNumber(0.7 + 0.1) // '0.7999999999999999'
Al crear BigNumber a partir de Number, tenga en cuenta que BigNumber se crea a partir del valor decimal toString () de Number, no a partir de su valor binario subyacente. Si se requiere lo último, pase el valor toString (2) de Number y especifique la base 2.
new BigNumber(Number.MAX_VALUE.toString(2), 2)
Los BigNumbers se pueden crear a partir de valores base de 2 a 36. Consulte ALFABETO para ampliar este rango.
a = new BigNumber(1011, 2) // "11"
b = new BigNumber('zz.9', 36) // "1295.25"
c = a.plus(b) // "1306.25"
Si no especifica la base 10 para los valores decimales, el rendimiento será mejor. Especifique la base 10 solo si desea limitar el número de posiciones decimales del valor de entrada a la configuración actual DECIMAL _ posiciones.
BigNumber es inmutable porque sus métodos no lo cambiarán.
0.3 - 0.1 // 0.19999999999999998
x = new BigNumber(0.3)
x.minus(0.1) // "0.2"
x // "0.3"
Los métodos que devuelven BigNumber se pueden encadenar.
x.dividedBy(y).plus(z).times(9)
x.times('1.23456780123456789e+9').plus(9876.5432321).dividedBy('4444562598.111772').integerValue()
Algunos nombres de métodos más largos tienen alias más cortos.
x.squareRoot().dividedBy(y).exponentiatedBy(3).isEqualTo(x.sqrt().div(y).pow(3)) // true
x.modulo(y).multipliedBy(z).eq(x.mod(y).times(z)) // true
Al igual que el tipo Number de JavaScript, existen métodos toExponential, toFixed y toPrecision.
x = new BigNumber(255.5)
x.toExponential(5) // "2.55500e+2"
x.toFixed(5) // "255.50000"
x.toPrecision(5) // "255.50"
x.toNumber() // 255.5
Puede especificar la base para toString.
Si no se especifica la base 10, el rendimiento será mejor, es decir, use toString () en lugar de toString (10). Especifique la base 10 solo si desea limitar el número de posiciones decimales de la cadena a la configuración actual DECIMAL _ posiciones.
x.toString(16) // "ff.8"
Existe un método toFormat que puede resultar útil para la internacionalización.
y = new BigNumber('1234567.898765')
y.toFormat(2) // "1,234,567.90"
Use el método set o config del constructor BigNumber para establecer el número máximo de lugares decimales involucrados en el resultado de la operación de división (es decir, división, raíz cuadrada, conversión de base u operación de potencia negativa).
Otras operaciones aritméticas siempre dan resultados precisos.
BigNumber.set({ DECIMAL_PLACES: 10, ROUNDING_MODE: 4 })
x = new BigNumber(2)
y = new BigNumber(3)
z = x.dividedBy(y) // "0.6666666667"
z.squareRoot() // "0.8164965809"
z.exponentiatedBy(-3) // "3.3749999995"
z.toString(2) // "0.1010101011"
z.multipliedBy(z) // "0.44444444448888888889"
z.multipliedBy(z).decimalPlaces(10) // "0.4444444445"
Hay un método toFraction con un parámetro de denominador máximo opcional
y = new BigNumber(355)
pi = y.dividedBy(113) // "3.1415929204"
pi.toFraction() // [ "7853982301", "2500000000" ]
pi.toFraction(1000) // [ "355", "113" ]
Y los métodos isNaN e isFinite, porque NaN e Infinity son valores válidos de BigNumber.
x = new BigNumber(NaN) // "NaN"
y = new BigNumber(Infinity) // "Infinity"
x.isNaN() && !y.isNaN() && !x.isFinite() && !y.isFinite() // true
El valor de BigNumber se almacena en formato de coma flotante decimal con coeficientes, exponentes y signos.
x = new BigNumber(-123.456);
x.c // [ 123, 45600000000000 ] coefficient (i.e. significand)
x.e // 2 exponent
x.s // -1 sign
Para un uso avanzado, puede crear varios constructores BigNumber, cada uno con su propia configuración independiente.
// Set DECIMAL_PLACES for the original BigNumber constructor
BigNumber.set({ DECIMAL_PLACES: 10 })
// Create another BigNumber constructor, optionally passing in a configuration object
BN = BigNumber.clone({ DECIMAL_PLACES: 5 })
x = new BigNumber(1)
y = new BN(1)
x.div(3) // '0.3333333333'
y.div(3) // '0.33333'
Para evitar llamar a toString o valueOf en BigNumber para obtener su valor en Node.js REPL, o úselo cuando use console.log
BigNumber.prototype[require('util').inspect.custom] = BigNumber.prototype.valueOf;