bignumber.js使用記錄

時間  2019-11-17
標籤 bignumber.js bignumber 使用 記錄 欄目 JavaScript 简体版
原文   原文鏈接

本文能夠看作是對bignumber.js官方文檔的翻譯。javascript

bignumber.js是一個用於進行數學運算的庫，支持任意精度。官網,能夠在官網的console中測試它的APIjava

constructor

/*
     * n {number|string|BigNumber} A numeric value.
     * [b] {number} The base of n. Integer, 2 to ALPHABET.length inclusive.
     */
    function BigNumber(n, b) {
        
    }
複製代碼

靜態方法

clone()

生成一個獨立的BigNumber構造函數git

var BN = BigNumber.clone()
BN(1).div(3).toNumber() //0.3333333333333333
複製代碼

config()

爲這個獨立的BigNumber構造函數設置參數github

主要包括如下幾個參數：算法

  1. DECIMAL_PLACES(默認值：20) 用於設置小數位數。在除法、開方、指數計算時會用到。
var BN = BigNumber.clone()
BN.config({DECIMAL_PLACES:4})
BN(1).div(3).toNumber() //0.3333，注意跟上面計算結果的區別
複製代碼
  1. ROUNDING_MODE(默認值4) 舍入模式，取值的意義可參照 文檔
//取值範圍：
    BigNumber.ROUND_UP = 0;         //遠離0方向舍入
    BigNumber.ROUND_DOWN = 1;       //向0方向舍入
    BigNumber.ROUND_CEIL = 2;       //向正無限大舍入
    BigNumber.ROUND_FLOOR = 3;      //向負無限大舍入
    BigNumber.ROUND_HALF_UP = 4;    //四捨五入：向最接近的數字方向舍入，若是與兩個相鄰數字的距離相等，則向上舍入。
    BigNumber.ROUND_HALF_DOWN = 5;  //向最接近的數字方向舍入，若是與兩個相鄰數字的距離相等，則向下舍入。
    BigNumber.ROUND_HALF_EVEN = 6;  //向最接近數字方向舍入，若是與兩個相鄰數字的距離相等，則向相鄰的偶數舍入
    BigNumber.ROUND_HALF_CEIL = 7;
    BigNumber.ROUND_HALF_FLOOR = 8;
複製代碼
  1. EXPONENTIAL_AT(默認值[-7,20]) 指數計數法
  2. RANGE(默認值[-1e+9,1e+9])
  3. CRYPTO(默認值 false) 用於設置BigNumber.random()的隨機生成算法。若是沒法設置爲true，則使用Math.random()生成隨機值。
  4. MODULO_MODE(默認值：ROUND_DOWN) 取模運算的模式
  5. POW_PRECISION(默認值：0) pow運算結果的精度
  6. FORMATE(格式化對應的設置)
默認值：
BigNumber.config().FORMAT
==============================
{
decimalSeparator: "."
fractionGroupSeparator: " "
fractionGroupSize: 0
groupSeparator: ","
groupSize: 3
secondaryGroupSize: 0
}
複製代碼

maximum([]),minimum([])

獲取數組中的最大值/最小值數組

random([precision])

返回一個僞隨機值，參數能夠指定小數點位數bash

實例方法

加法：.plus(n [, base]) ⇒ BigNumber

0.1 + 0.2                       // 0.30000000000000004
x = new BigNumber(0.1)
y = x.plus(0.2)                 // '0.3'
BigNumber(0.7).plus(x).plus(y)  // '1'
x.plus('0.1', 8)                // '0.225'
複製代碼

減法：.minus(n [, base]) ⇒ BigNumber

0.3 - 0.1                       // 0.19999999999999998
x = new BigNumber(0.3)
x.minus(0.1)                    // '0.2'
x.minus(0.6, 20)                // '0'
複製代碼

乘法：.times(n [, base]) ⇒ BigNumber; m.ultipliedBy(n [, base]) ⇒ BigNumber;

0.6 * 3                         // 1.7999999999999998
x = new BigNumber(0.6)
y = x.multipliedBy(3)           // '1.8'
BigNumber('7e+500').times(y)    // '1.26e+501'
x.multipliedBy('-a', 16)        // '-6 複製代碼

除法

普通除法運算： .div(n [, base]) ⇒ BigNumber； .dividedBy(n [, base]) ⇒ BigNumber

x = new BigNumber(355)
y = new BigNumber(113)
x.dividedBy(y)                  // '3.14159292035398230088'
x.div(5)                        // '71'
x.div(47, 16)                   // '5'
複製代碼

注意： 除法計算結果會根據DECIMAL_PLACES和ROUNDING_MODE兩個屬性設置進行舍入。dom

除法，返回整數： .idiv(n [, base]) ⇒ BigNumber；.dividedToIntegerByv(n [, base]) ⇒ BigNumber

x = new BigNumber(355)
y = new BigNumber(113)
x.dividedBy(y)                  // '3.14159292035398230088'
x.div(5)                        // '71'
x.div(47, 16)                   // '5'
複製代碼

取模/取餘： .mod(n [, base]) ⇒ BigNumber；modulo.(n [, base]) ⇒ BigNumber

1 % 0.9                         // 0.09999999999999998
x = new BigNumber(1)
x.modulo(0.9)                   // '0.1'
y = new BigNumber(33)
y.mod('a', 33)                  // '3'
複製代碼

注意： 取模/取餘運算受MODULO_MODE設置影響ide

指數運算： .pow(n [, m]) ⇒ BigNumber;.exponentiatedBy(n [, m]) ⇒ BigNumber

Math.pow(0.7, 2)                // 0.48999999999999994
x = new BigNumber(0.7)
x.exponentiatedBy(2)            // '0.49'
BigNumber(3).pow(-2)            // '0.11111111111111111111'
複製代碼

注意： n表明的是指數。若是n<0,計算結果確定是小數，因此計算結果會受 DECIMAL_PLACES 和 ROUNDING_MODE影響。函數

開平方：.sqrt() ⇒ BigNumber；.squareRoot.() ⇒ BigNumber

x = new BigNumber(16)
x.squareRoot()                  // '4'
y = new BigNumber(3)
y.sqrt()                        // '1.73205080756887729353'
複製代碼

比較大小： .comparedTo(n [, base]) ⇒ number

比較結果，參考以下表：

1	操做數>n
-1	操做數<n
0	操做數==n
null	操做數或者n不是數字
複製代碼

舉例：

x = new BigNumber(Infinity)
y = new BigNumber(5)
x.comparedTo(y)                 // 1
x.comparedTo(x.minus(1))        // 0
y.comparedTo(NaN)               // null
y.comparedTo('110', 2)          // -1
複製代碼

精度調整

.dp([dp [, rm]]) ⇒ BigNumber|number；decimalPlaces.[dp [, rm]]) ⇒ BigNumber|number 根據dp(decimals places)和rm(round mode)對操做數進行舍入

x = new BigNumber(1234.56)
x.decimalPlaces(1)                     // '1234.6'
x.dp()                                 // 2  若是不傳dp，則函數返回的是操做數的小數點的位數
x.decimalPlaces(2)                     // '1234.56'
x.dp(10)                               // '1234.56'
x.decimalPlaces(0, 1)                  // '1234'
x.dp(0, 6)                             // '1235'
x.decimalPlaces(1, 1)                  // '1234.5'
x.dp(1, BigNumber.ROUND_HALF_EVEN)     // '1234.6'
x                                      // '1234.56'
複製代碼

取整：.integerValue([rm]) ⇒ BigNumber

根據rm(round mode)返回操做數的整數部分

x = new BigNumber(123.456)
x.integerValue()                        // '123'
x.integerValue(BigNumber.ROUND_CEIL)    // '124'
y = new BigNumber(-12.7)
y.integerValue()                        // '-13'
y.integerValue(BigNumber.ROUND_DOWN)    // '-12',向0舍入
複製代碼

有效數字 .sd([d [, rm]]) ⇒ BigNumber|number；precision.([d [, rm]]) ⇒ BigNumber|number

什麼是有效數字？--->從該數的第一個非零數字起，直到末尾數字止的數字稱爲有效數字，如0.618的有效數字有三個，分別是6,1,8。

x = new BigNumber(9876.54321)
x.precision(6)                         // '9876.54'
x.sd()                                 // 9 若是省略參數d，則返回有效數字個數
x.precision(6, BigNumber.ROUND_UP)     // '9876.55'
x.sd(2)                                // '9900' //todo
x.precision(2, 1)                      // '9800'    //todo
y = new BigNumber(987000)
y.precision()                          // 3
y.sd(true)                             // 6,如多參數sd爲true，則整數部分後邊的0也會被認爲是有效數字
複製代碼

.toFixed([dp [, rm]]) ⇒ string

返回一個字符串，小數位根據dp截取或者填充。
注意： Unlike Number.prototype.toFixed, which returns exponential notation if a number is greater or equal to 1021, this method will always return normal notation.

跟Number.prototype.toFixed(dp)的異同

  1. 若是省略參數dp，BigNumber(1.123).toFixed() 原樣返回'1.123';而1.123.toFixed()會去掉全部小數位，只返回整數位'1'
  2. 若是操做數大於10^21，BigNumber(10^21).toFixed()會跟普通數字同樣返回；10^21.toFixed() 會經過指數形式返回
Math.pow(10,20).toFixed()   //"100000000000000000000"
Math.pow(10,21).toFixed()   //"1e+21"

BigNumber(10).pow(20).toFixed() //"100000000000000000000"
BigNumber(10).pow(21).toFixed() //"1000000000000000000000"
複製代碼

示例：

x = 3.456
y = new BigNumber(x)
x.toFixed()                     // '3'
y.toFixed()                     // '3.456'
y.toFixed(0)                    // '3'
x.toFixed(2)                    // '3.46'
y.toFixed(2)                    // '3.46'
y.toFixed(2, 1)                 // '3.45'  (ROUND_DOWN)
x.toFixed(5)                    // '3.45600'
y.toFixed(5)                    // '3.45600'
複製代碼

注意： toFixed()方法與dp()方法的主要區別是，toFixed返回的是字符串，若是小數位不夠的話會用0補齊；dp()方法返回的是BigNumber|number，小數位不夠的話會忽略

數字格式化 .toFormat([dp [, rm]]) ⇒ string

返回字符串，會根據dp和rm進行舍入,並根據FORMAT屬性進行格式化。

format = {
    decimalSeparator: '.',
    groupSeparator: ',',
    groupSize: 3,
    secondaryGroupSize: 0,
    fractionGroupSeparator: ' ',
    fractionGroupSize: 0
}
BigNumber.config({ FORMAT: format })

x = new BigNumber('123456789.123456789')
x.toFormat()                    // '123,456,789.123456789'
x.toFormat(1)                   // '123,456,789.1'
複製代碼

轉換爲js 基礎數值類型 .toNumber() ⇒ number

效果與使用+運算符一致

x = new BigNumber(456.789)
x.toNumber()                    // 456.789
+x                              // 456.789

複製代碼
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程