NaN 是唯一一個 不與自身相等的值：

> NaN === NaN
false

嚴格相等（===）也由 Array.prototype.indexOf 使用。因此，你無法透過該方法在陣列中搜尋 NaN

> [ NaN ].indexOf(NaN)
-1

如果你想檢查值是否為 NaN，你必須使用全域 函式 isNaN()：

> isNaN(NaN)
true
> isNaN(33)
false

但是，isNaN 無法正確處理非數字，因為它會先將這些轉換為數字。該轉換可能會產生 NaN，然後函式會不正確地傳回 true

> isNaN('xyz')
true

因此，最好將 isNaN 與 類型檢查結合使用：

function myIsNaN(value) {
    return typeof value === 'number' && isNaN(value);
}

或者，你可以檢查該值是否不與自身相等（因為 NaN 是具有此特徵的唯一值）。但那樣 較難理解：

function myIsNaN(value) {
    return value !== value;
}

請注意，此行為是由 IEEE 754 規定的。如第 7.11 節「比較謂詞的詳細資訊」中所述：^[15]

數字的絕對值能變多大是由其內部表示法決定的（如 數字的內部表示法 中所討論的），它是

指數必須介於（且排除）−1023 和 1024 之間。如果指數太小，數字將變為 0。如果指數太大，它將變為 Infinity。2¹⁰²³ 仍可表示，但 2¹⁰²⁴ 則不行

> Math.pow(2, 1023)
8.98846567431158e+307
> Math.pow(2, 1024)
Infinity

除以 零會產生 Infinity 作為錯誤值：

> 3 / 0
Infinity
> 3 / -0
-Infinity

如果您嘗試使用另一個 Infinity 來「中和」一個 Infinity，您將得到 錯誤結果 NaN：

> Infinity - Infinity
NaN
> Infinity / Infinity
NaN

如果您嘗試超越 Infinity，您仍會得到 Infinity

> Infinity + Infinity
Infinity
> Infinity * Infinity
Infinity

嚴格和寬鬆相等 對 Infinity 有效：

> var x = Infinity;
> x === Infinity
true

此外，全域函數 isFinite() 允許您檢查一個值是否是一個實際數字（既不是無限大也不是 NaN）：

> isFinite(5)
true
> isFinite(Infinity)
false
> isFinite(NaN)
false

JavaScript 費盡心思隱藏了存在兩個零的事實。由於它們不同通常無關緊要，建議您配合單一零的錯覺。讓我們探討如何維持這種錯覺。

在 JavaScript 中，您通常會寫 0，表示 +0。但 -0 也會顯示為 0。這是您在使用瀏覽器命令列或 Node.js REPL 時所看到的

> -0
0

這是因為標準 toString() 方法會將 兩個零都轉換為相同的 '0':

> (-0).toString()
'0'
> (+0).toString()
'0'

相等性也不會區分 零。甚至 === 也不行:

> +0 === -0
true

Array.prototype.indexOf 使用 === 搜尋元素，維持錯覺

> [ -0, +0 ].indexOf(+0)
0
> [ +0, -0 ].indexOf(-0)
0

排序運算子也認為零相等

> -0 < +0
false
> +0 < -0
false

您 如何 實際觀察到兩個零不同？您可以除以零（-Infinity 和 +Infinity 可以 用 === 區分）：

> 3 / -0
-Infinity
> 3 / +0
Infinity

執行零除法的另一種方式是透過 Math.pow() (請參閱 數值函數)

> Math.pow(-0, -1)
-Infinity
> Math.pow(+0, -1)
Infinity

Math.atan2() (請參閱 三角函數) 也顯示零有不同：

> Math.atan2(-0, -1)
-3.141592653589793
> Math.atan2(+0, -1)
3.141592653589793

區分兩個零的標準方式是零除法。因此，偵測負零的函數看起來像這樣：

function isNegativeZero(x) {
    return x === 0 && (1/x < 0);
}

以下是函數的使用方式

> isNegativeZero(0)
false
> isNegativeZero(-0)
true
> isNegativeZero(33)
false

如果您使用高達 53 位元大小的整數，您沒問題。遺憾的是，您在程式設計中經常會遇到 64 位元無符號整數（Twitter ID、資料庫等）。這些必須儲存在 JavaScript 中的字串中。如果您想要對此類整數執行算術運算，您需要特殊函式庫。有計畫將較大的整數帶入 JavaScript，但這需要一段時間。

ECMAScript 6 將提供下列常數：

Number.MAX_SAFE_INTEGER = Math.pow(2, 53)-1;
Number.MIN_SAFE_INTEGER = -Number.MAX_SAFE_INTEGER;

它還將提供一個函數，用於確定一個整數是否安全：

Number.isSafeInteger = function (n) {
    return (typeof n === 'number' &&
        Math.round(n) === n &&
        Number.MIN_SAFE_INTEGER <= n &&
        n <= Number.MAX_SAFE_INTEGER);
}

對於給定的值 n，此函數首先檢查 n 是否為數字和整數。如果兩個檢查都成功，則 n 是安全的，如果它大於或等於 MIN_SAFE_INTEGER 且小於或等於 MAX_SAFE_INTEGER。

我們如何確保算術運算的結果正確？例如，以下結果明顯不正確：

> 9007199254740990 + 3
9007199254740992

我們有兩個安全的運算元，但結果不安全

> Number.isSafeInteger(9007199254740990)
true
> Number.isSafeInteger(3)
true
> Number.isSafeInteger(9007199254740992)
false

以下結果也不正確

> 9007199254740995 - 10
9007199254740986

這次，結果是安全的，但運算元之一不是

> Number.isSafeInteger(9007199254740995)
false
> Number.isSafeInteger(10)
true
> Number.isSafeInteger(9007199254740986)
true

因此，僅當所有運算元和結果都安全時，應用整數運算元 op 的結果才保證正確。更正式地說

isSafeInteger(a) && isSafeInteger(b) && isSafeInteger(a op b)

暗示 a op b 是正確的結果。

如果遮罩（第二個運算元）為 0，您不會變更任何位元，結果為第一個運算元，強制轉換為有符號 32 位元整數。 這是執行這種強制轉換的標準方法，例如，asm.js 使用它（請參閱 JavaScript 是否夠快？)

// Convert x to a signed 32-bit integer
function ToInt32(x) {
    return x | 0;
}

ToInt32() 移除小數部分並套用模數 2³²：

> ToInt32(1.001)
1
> ToInt32(1.999)
1
> ToInt32(1)
1
> ToInt32(-1)
-1
> ToInt32(Math.pow(2, 32)+1)
1
> ToInt32(Math.pow(2, 32)-1)
-1

對按位元或運算有效的技巧也適用於位元移位運算子：若位移位元數為零，則位元移位運算的結果為第一個運算元，強制轉換為 32 位元整數。以下是透過位元移位運算子實作 ECMAScript 規格運算的範例：

// Convert x to a signed 32-bit integer
function ToInt32(x) {
    return x << 0;
}

// Convert x to a signed 32-bit integer
function ToInt32(x) {
    return x >> 0;
}

// Convert x to an unsigned 32-bit integer
function ToUint32(x) {
    return x >>> 0;
}

以下是 ToUint32() 的動作：

> ToUint32(-1)
4294967295
> ToUint32(Math.pow(2, 32)-1)
4294967295
> ToUint32(Math.pow(2, 32))
0

您必須自行決定是否值得為了略微提升效率而讓程式碼更難理解。另外，請注意按位元運算子會將自己的人為限制在 32 位元，這通常既不必要也不實用。使用其中一個 Math 函式，可能搭配 Math.abs()，會更能說明自身且可能是更好的選擇。

基底的範圍為 2 ≤ radix ≤ 36。它會決定要剖析的數字的基底。若基底大於 10，除了 0–9 之外，字母也會用作數字（不區分大小寫）。

若 radix 遺失，則假設為 10，除非 str 以「0x」或「0X」開頭，這種情況下 radix 會設為 16（十六進位）

> parseInt('0xA')
10

若 radix 已為 16，則十六進位字首為選用

> parseInt('0xA', 16)
10
> parseInt('A', 16)
10

到目前為止，我已根據 ECMAScript 規格說明 parseInt() 的行為。此外，有些引擎會在 str 以零開頭時將基底設為 8

> parseInt('010')
8
> parseInt('0109')  // ignores digits ≥ 8
8

因此，最好總是明確陳述基底，並始終使用兩個引數呼叫 parseInt()。

以下是一些範例

> parseInt('')
NaN
> parseInt('zz', 36)
1295
> parseInt('   81', 10)
81

> parseInt('12**', 10)
12
> parseInt('12.34', 10)
12
> parseInt(12.34, 10)
12

不要使用 parseInt() 將數字轉換為整數。最後一個範例讓我們希望我們可以使用 parseInt() 將數字轉換為整數。唉，以下是一個轉換不正確的範例：

> parseInt(1000000000000000000000.5, 10)
1

引數會先轉換為字串

> String(1000000000000000000000.5)
'1e+21'

parseInt 認為「e」不是整數數字，因此在 1 之後停止剖析。以下為另一個範例

> parseInt(0.0000008, 10)
8
> String(0.0000008)
'8e-7'

parseInt() 不應使用於將數字轉換為整數：強制轉換為字串是一個不必要的迂迴，而且即使如此，結果也不總是正確。

parseInt() 確實可用於剖析字串，但您必須知道它會在第一個非法數字處停止。透過 Number() 剖析字串（請參閱 函數 Number）較不寬容，但可能會產生非整數。

計算二進制補數 (或反碼) 的兩個常見方法如下

32 位元整數沒有明確的符號，但您仍可編碼負數。例如，−1 可編碼為 1 的二補數：將 1 加到結果會產生 0 (在 32 位元內)。正負數字之間的界線是流動的；4294967295 (2³²−1) 和 −1 在這裡是同一個整數。但當您將此類整數從 JavaScript 數字轉換為 JavaScript 數字，或從 JavaScript 數字轉換為此類整數時，您必須決定符號，因為 JavaScript 數字有明確的符號，而不是隱含的符號。因此，有符號 32 位元整數 分成兩組：

最高位元通常稱為符號位元。因此，4294967295 解釋為有符號 32 位元整數時，會在轉換為 JavaScript 數字時變成 −1

> ToInt32(4294967295)
-1

ToInt32() 在 透過位元運算子處理 32 位元整數 中說明。

在以下範例中，我們透過下列兩個運算處理二進制數字：

對於基數 10，toString() 在兩種情況下使用指數表示法（小數點前只有一個數字）。首先，如果數字小數點前的數字超過 21 個

> 1234567890123456789012
1.2345678901234568e+21
> 123456789012345678901
123456789012345680000

其次，如果數字以 0. 開頭，後面接著超過五個零和一個非零數字

> 0.0000003
3e-7
> 0.000003
0.000003

在所有其他情況下，都會使用固定表示法。