摘要：表示正數(shù)，表示負(fù)數(shù)。是一個無符號整數(shù)，因?yàn)殚L度是位，取值范圍是。浮點(diǎn)數(shù)具體數(shù)值的實(shí)際表示。例如對于單精度浮點(diǎn)數(shù)，指數(shù)部分實(shí)際最小值是，對應(yīng)的尾數(shù)部分從一直到，相鄰兩小浮點(diǎn)數(shù)之間的距離都是而與最近的浮點(diǎn)數(shù)即最小的非規(guī)約數(shù)也是。

例如用二進(jìn)制表示 0.8125

0.8125
0.8125*2 = 1.625 取整為 1
0.625*2=1.25 取整為 1
0.25*2=0.5 取整為 0
0.5*2=1 取整為 1
若是 *2 始終無法得到 1，就一直到位數(shù)用完，這也是浮點(diǎn)數(shù)并不精確的原因
即 0.8125 的二進(jìn)制表示是 0.1101
即 0.8125 = 2^-1*1+2^-2*1+2^-3*0+2^-4*1
即 0.8125 = 0.5 + 0.25 + 0.0625

所以 0.1 到 0.9 的 9 個小數(shù)中，只有 0.5 可以用二進(jìn)制精確表示

在 JS 中，所有的數(shù)字都是基于 IEEE 754 的浮點(diǎn)數(shù)。除了浮點(diǎn)數(shù)，還有定點(diǎn)數(shù)，兩者的區(qū)別就在于小數(shù)點(diǎn)的處理。同樣是用64個bit表示一個數(shù)，定點(diǎn)數(shù)會用前 N 位來表示一個數(shù)的整數(shù)部分，用后 64 - N 來表示一個數(shù)的小數(shù)部分，這個 N 是固定的，對所有的數(shù)都是一樣的。

對于64位的浮點(diǎn)數(shù)，最高的1位是符號位 S，接著是11位的指數(shù) E，剩下的52位為有效數(shù)字 M

S，Sign（1bit）：表示浮點(diǎn)數(shù)是正數(shù)還是負(fù)數(shù)。0表示正數(shù)，1表示負(fù)數(shù)。

E，Exponent（11bit）：指數(shù)部分。類似于科學(xué)記數(shù)法的 M*10^N 中的 N，只不過不是以10為底，而是以2為底。E是一個無符號整數(shù)，因?yàn)殚L度是11位，取值范圍是 0~2047。但是科學(xué)計數(shù)法中的指數(shù)是可以為負(fù)數(shù)的，所以再減去一個中間數(shù) 1023，[0,1022]表示為負(fù)，[1024,2047] 表示為正

M，Mantissa（52bit）：基數(shù)部分。浮點(diǎn)數(shù)具體數(shù)值的實(shí)際表示。

所以計算機(jī)將 5.8125 存儲為浮點(diǎn)數(shù)的過程如下

用二進(jìn)制表示5.8125，得到 101.1101

用類似科學(xué)計數(shù)法表示二進(jìn)制數(shù) 101.1101，得到 1.011101 * 2 ^ 2

偏移指數(shù)部分，在 5.8125 中，指數(shù)為2，是正數(shù)，但實(shí)際上指數(shù)也可能為負(fù)數(shù)，例如如果是0.8125，指數(shù)就為-1了。11位的指數(shù)部分，為了包括負(fù)數(shù)，所有需要偏移 2^10-1，即 1023。所以指數(shù)偏移后為1025=2+1023，用二進(jìn)制表示 10000000001

處理整數(shù)部分，用類似科學(xué)計數(shù)法表示二進(jìn)制數(shù)后，小數(shù)點(diǎn)前面總為1，可以將這個1忽略，這樣可以增加表示數(shù)的范圍

綜上，5.8125 在計算機(jī)中的存儲形式 0(1位) + 0111,1111,111(11位) + 011101(6位) +0…0(46位)

M部分是二進(jìn)制表示數(shù)，E控制小數(shù)點(diǎn)的位置，S控制數(shù)的正負(fù)

JS 中所有的數(shù)字都是浮點(diǎn)數(shù)，64位浮點(diǎn)數(shù)能準(zhǔn)確表示的實(shí)數(shù)是有限的，例如之前提到， 0.1 到 0.9 的 9 個小數(shù)中，只有 0.5 可以用浮點(diǎn)數(shù)準(zhǔn)確表示

盜圖來源JavaScript浮點(diǎn)數(shù)陷阱及解法

也因?yàn)?JS 中所有的數(shù)字都是以浮點(diǎn)數(shù)的形式保存的，所以數(shù)字后面的“.”會被當(dāng)作小數(shù)點(diǎn)來處理

所以有

var a = 0.42;        // 0.42
var b = .42;        // 0.42
42.toFixed( 3 );    // SyntaxError
(42).toFixed( 3 );    // "42.000"
0.42.toFixed( 3 );    // "0.420"
42..toFixed( 3 );    // "42.000"

64位浮點(diǎn)數(shù)，M部分最大為52個1 + 被忽略的1，E部分最大為 2046-1023 = 1023，

為什么不是 2047-1023 = 1024，因?yàn)檫@個1024要用來表示Infinity

所以最大的二進(jìn)制數(shù)位 1.1111…1(小數(shù)點(diǎn)后面52個1) * 2 ^ 1023

在計算機(jī)中存儲形態(tài)為 0 | 111 1111 1110 | 111111...111(52個1)

let sum = 0
for (let i = 0; i < 53; i++) {
    sum = sum + Math.pow(2, 1023 - i)
    console.log(sum)
}
sum // 1.7976931348623157e+308
Number.MAX_VALUE // 1.7976931348623157e+308
// 如果把代碼改成 i < 53，得到 1.7976931348623155e+308

這個值是 最接近0且大于0的，且是精確表示的數(shù)

64位浮點(diǎn)數(shù)，M部分最小為0 + 被忽略的1，E部分最小為 0-1023 = -1023，

1*2^-1023，即二進(jìn)制 0.00…001(1之前有1023個0)

Math.pow(2, -1023) // 1.1125369292536007e-308
Number.MIN_VALUE // 5e-324

嗯？WHY？

“如果浮點(diǎn)數(shù)的指數(shù)部分的編碼值是0，尾數(shù)為非零，那么這個浮點(diǎn)數(shù)將被稱為非規(guī)約形式的浮點(diǎn)數(shù)。IEEE 754標(biāo)準(zhǔn)規(guī)定：非規(guī)約形式的浮點(diǎn)數(shù)的指數(shù)偏移值比規(guī)約形式的浮點(diǎn)數(shù)的指數(shù)偏移值大1.例如，最小的規(guī)約形式的單精度浮點(diǎn)數(shù)的指數(shù)部分編碼值為1，指數(shù)的實(shí)際值為-126；而非規(guī)約的單精度浮點(diǎn)數(shù)的指數(shù)域編碼值為0，對應(yīng)的指數(shù)實(shí)際值也是-126而不是-127。實(shí)際上非規(guī)約形式的浮點(diǎn)數(shù)仍然是有效可以使用的，只是它們的絕對值已經(jīng)小于所有的規(guī)約浮點(diǎn)數(shù)的絕對值；即所有的非規(guī)約浮點(diǎn)數(shù)比規(guī)約浮點(diǎn)數(shù)更接近0。規(guī)約浮點(diǎn)數(shù)的尾數(shù)大于等于1且小于2，而非規(guī)約浮點(diǎn)數(shù)的尾數(shù)小于1且大于0.

...

除了規(guī)約浮點(diǎn)數(shù)，IEEE754-1985標(biāo)準(zhǔn)采用非規(guī)約浮點(diǎn)數(shù)，用來解決填補(bǔ)絕對值意義下最小規(guī)格數(shù)與零的距離。（舉例說，正數(shù)下，最大的非規(guī)格數(shù)等于最小的規(guī)格數(shù)。而一個浮點(diǎn)數(shù)編碼中，如果exponent=0，且尾數(shù)部分不為零，那么就按照非規(guī)約浮點(diǎn)數(shù)來解析）非規(guī)約浮點(diǎn)數(shù)源于70年代末IEEE浮點(diǎn)數(shù)標(biāo)準(zhǔn)化專業(yè)技術(shù)委員會醞釀浮點(diǎn)數(shù)二進(jìn)制標(biāo)準(zhǔn)時，Intel公司對漸進(jìn)式下溢出（gradual underflow）的力薦。當(dāng)時十分流行的DEC VAX機(jī)的浮點(diǎn)數(shù)表示采用了突然式下溢出（abrupt underflow）。如果沒有漸進(jìn)式下溢出，那么0與絕對值最小的浮點(diǎn)數(shù)之間的距離（gap）將大于相鄰的小浮點(diǎn)數(shù)之間的距離。例如單精度浮點(diǎn)數(shù)的絕對值最小的規(guī)約浮點(diǎn)數(shù)是,它與絕對值次小的規(guī)約浮點(diǎn)數(shù)之間的距離為。如果不采用漸進(jìn)式下溢出，那么絕對值最小的規(guī)約浮點(diǎn)數(shù)與0的距離是相鄰的小浮點(diǎn)數(shù)之間距離的倍！可以說是非常突然的下溢出到0。這種情況的一種糟糕后果是：兩個不等的小浮點(diǎn)數(shù)X與Y相減，結(jié)果將是0.訓(xùn)練有素的數(shù)值分析人員可能會適應(yīng)這種限制情況，但對于普通的程序員就很容易陷入錯誤了。采用了漸進(jìn)式下溢出后將不會出現(xiàn)這種情況。例如對于單精度浮點(diǎn)數(shù)，指數(shù)部分實(shí)際最小值是（-126），對應(yīng)的尾數(shù)部分從,一直到, ，相鄰兩小浮點(diǎn)數(shù)之間的距離（gap）都是；而與0最近的浮點(diǎn)數(shù)（即最小的非規(guī)約數(shù)）也是。“

以上文字來源非規(guī)約形式的浮點(diǎn)數(shù)

總結(jié)來說，規(guī)定當(dāng)浮點(diǎn)數(shù)的指數(shù)為允許的最小指數(shù)值，尾數(shù)不必是規(guī)范化的。

M部分最小為51個0和1個1

所以最小二進(jìn)制數(shù)，0.00….001(小數(shù)點(diǎn)后面51個0)*2^-1022，即二進(jìn)制0.00..001(1之前有52+1022個0)

Math.pow(2, -1074) // 5e-324

從 Number.MIN_SAFE_INTEGER 到 Number.MAX_SAFE_INTEGER 之間連續(xù)的整數(shù)都是可以準(zhǔn)確表示的

E為52，算上偏移+1023，為1075，用二進(jìn)制表示 10000110011

M為52個1，算上默認(rèn)的1，為1.11….1(小數(shù)點(diǎn)后面52個1)

在計算機(jī)中存儲形態(tài)為 0 | 100 0011 0011 | 111111...111(52個1)

整體來看就是 1.11…1(小數(shù)點(diǎn)后面52個1)*2^52，即 53個1

let sum = 0
for (let i = 0; i < 53; i++) {
    sum = sum + Math.pow(2, i)
}
sum // 9007199254740991
Number.MAX_SAFE_INTEGER // 9007199254740991

將 S 位表示為1

在計算機(jī)中存儲形態(tài)為 1 | 100 0011 0011 | 111111...111(52個1)

0.1 轉(zhuǎn)成二進(jìn)制 0.000110011001100...

即 1.1001100 * 2^-4

指數(shù)位偏移 1019 = -4+1023，用二進(jìn)制表示 1111 1110 11

0.1 在計算機(jī)中存儲形態(tài) 0 | 011 1111 1011|1001 1001 1001 1001 1001(12個1001) 1010

最后四位不是 1001 而是 1010，是考慮到 1001的下一位是1，故進(jìn)一位

再將其轉(zhuǎn)換成二進(jìn)制 1.1001 1001 1001(12個1001)1010 * 2^-4

其實(shí)呢

0.1.toString(2) // "0.0001100110011001100110011001100110011001100110011001101"

0.2 轉(zhuǎn)成二進(jìn)制 0.0011001100110011...

即 1.1001 1001…*2^-3

指數(shù)位偏移 1020 = -3+1023，用二進(jìn)制表示 1111 1111 00

0.2 在計算機(jī)中存儲形態(tài) 0 | 011 1111 1100 | 1001 1001 1001 1001 1001(12個1001) 1010

最后四位不是 1001 而是 1010，是考慮到 1001的下一位是1，故進(jìn)一位

再將其轉(zhuǎn)換成二進(jìn)制 1.1001 1001 1001(12個1001) 1010 *2^-3

0.2.toString(2) // "0.001100110011001100110011001100110011001100110011001101"

將這兩個二進(jìn)制數(shù)相加

寫個小程序計算一下

function addBinary(a, b) {
    let aStr = a,
        bStr = b
    let addLength = aStr.length - bStr.length
    if (addLength > 0) {
        bStr = bStr + "0".repeat(addLength)
    } else if (addLength < 0) {
        aStr = aStr + "0".repeat(-addLength)
    }
    let addFlag = 0
    let arr1 = [...aStr]
    let arr2 = [...bStr]
    let length = arr1.length
    let arr3 = []
    for (let i = 0; i < length; i++) {
        let el1 = arr1.pop()
        let el2 = arr2.pop()
        if (el1 * 1 + el2 * 1 === 0) {
            arr3.unshift(addFlag)
            addFlag = 0
        } else if (el1 * 1 + el2 * 1 === 1) {
            if (addFlag === 1) {
                arr3.unshift(0)
                addFlag = 1
            } else {
                arr3.unshift(1)
                addFlag = 0
            }
        } else if (el1 * 1 + el2 * 1 === 2) {
            arr3.unshift(addFlag)
            addFlag = 1
        }
    }
    return arr3.join("")
}
// 參數(shù)a,b 為小數(shù)后面的部分
addBinary("0001100110011001100110011001100110011001100110011001101","001100110011001100110011001100110011001100110011001101")
// 0100110011001100110011001100110011001100110011001100111

加上整數(shù)部分，得到 0.0100110011001100110011001100110011001100110011001100111

將其轉(zhuǎn)換為實(shí)數(shù)

function convertBinary(a) {
    return [...a].reduce((acc, cur, i) => {
        acc = acc + cur * Math.pow(2, -1 * (i + 1))
        return acc
    }, 0)
}
// 參數(shù)a 依然為小數(shù)后面的部分
convertBinary("0100110011001100110011001100110011001100110011001100111")
// 0.30000000000000004

if (!Number.EPSILON) {
    Number.EPSILON = Math.pow(2,-52);
}

用 Number.EPSILON（容差） 來比較兩個 number 的等價性

The value of Number.EPSILON is the difference between 1 and the smallest value greater than 1 that is representable as a Number value, which is approximately 2.2204460492503130808472633361816 x 10???16.

根據(jù)ECMASCRIPT-262定義 Number.EPSILON 是大于1的最小可表示數(shù)與1的差

function numbersCloseEnoughToEqual(n1,n2) {
    return Math.abs( n1 - n2 ) < Number.EPSILON;
}

var a = 0.1 + 0.2;
var b = 0.3;

numbersCloseEnoughToEqual( a, b );                    // true
numbersCloseEnoughToEqual( 0.0000001, 0.0000002 );    // false

根據(jù) IEEE 754

如果指數(shù)是0并且尾數(shù)的小數(shù)部分是0，這個數(shù)±0（和符號位相關(guān)）

如果指數(shù) =并且尾數(shù)的小數(shù)部分是0，這個數(shù)是±∞（同樣和符號位相關(guān)）

如果指數(shù) = 并且尾數(shù)的小數(shù)部分非0，這個數(shù)表示為不是一個數(shù)（NaN）

var a = Number.MAX_VALUE;    // 1.7976931348623157e+308
a + 1 === a;                // true
a + a;                        // Infinity
a + Math.pow( 2, 970 );        // Infinity
a + Math.pow( 2, 969 );        // 1.7976931348623157e+308

據(jù) IEEE 754

Infinity 中 E的二進(jìn)制表示為 111 1111 1111，M為1(默認(rèn)) + 52個0

Infinity 在計算機(jī)中存儲形態(tài) 0 | 111 1111 1111 | 0000(52個0)

Math.pow(2, 1024) // Infinity
Math.pow(2, 1023) + Math.pow(2, 1022) + ... + Math.pow(2, 971) // 1.7976931348623157e+308 

可以看到 Infinity 和 Number.MAX_VALUE 之間相差 Math.pow(2, 971)

IEEE 754 “就近舍入”，Number.MAX_VALUE + Math.pow( 2, 969 ) 比起 Infinity 更接近于 Number.MAX_VALUE，所以它“向下舍入”，而 Number.MAX_VALUE + Math.pow( 2, 970 ) 距離 Infinity 更近，所以它“向上舍入”。

再我的理解看來，凡是大于等于 Number.MAX_VALUE + Math.pow( 2, 970 ) 的數(shù)字都用 Infinity 來存儲

存儲形態(tài)都是 0 | 111 1111 1111 | 0000(52個0)

Number.MAX_VALUE + Math.pow(2,971) === Number.MAX_VALUE + Math.pow(2,972) // true

首先 typeof NaN 返回 number，NaN表示不是數(shù)字的數(shù)字

NaN 為數(shù)字表現(xiàn)為它來源于數(shù)學(xué)計算，

NaN 不是數(shù)字表現(xiàn)為計算過程中的參數(shù)并不符合要求，導(dǎo)致計算結(jié)果不是數(shù)字

"foo"/"foo" // NaN
1 * "fp" // NaN
1 / 0    // Infinity
0 / 0    // NaN
Infinity / Infinity // NaN
Infinity / 1 // Infinity
Infinity / 0 // Infinity

如何判斷一個數(shù)值是 NaN

typeof n === "number" && window.isNaN(n)

n !== n

在整個語言中 NaN 是唯一一個自己與自己不相等的值

Number.isNaN(n)

Object.is(0, -0);            // false
Object.is(-0, -0);           // true
Object.is(NaN, 0/0);         // true

function fakeIs(v1, v2) {
    // 測試 `-0`
    if (v1 === 0 && v2 === 0) {
        return 1 / v1 === 1 / v2;
    }
    // 測試 `NaN`
    if (v1 !== v1) {
        return v2 !== v2;
    }
    // 其他情況
    return v1 === v2;
}

numObj.toExponential(fractionDigits)

fractionDigits 規(guī)定了小數(shù)位的位數(shù)

以指數(shù)形式展現(xiàn)數(shù)字，科學(xué)計數(shù)法

numObj.toFixed(digits)

digits 規(guī)定了小數(shù)位的位數(shù)，不足用 0 填充

固定小數(shù)位數(shù)

numObj.toPrecision(precision)

precision 規(guī)定了整數(shù)位+小數(shù)位的位數(shù)

以固定精度返回數(shù)字

Numbers in JavaScript

二進(jìn)制與JS中的浮點(diǎn)值運(yùn)算

你不懂JS/類型與文法/值

二進(jìn)制表示浮點(diǎn)數(shù)的在線轉(zhuǎn)換

FloatConverter