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は、2つのゼロがあるという事実を隠すために非常に努力しています。通常は違いが問題にならないことを考えると、単一のゼロという幻想に沿ってプレイすることをお勧めします。この幻想がどのように維持されているかを調べてみましょう。

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

2つのゼロが実際に異なることをどのように確認できますか？ゼロで除算できます（-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

2つのゼロを区別する標準的な方法は、ゼロ除算です。したがって、負のゼロを検出するための関数は、次のようになります。

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

2つの安全なオペランドがありますが、結果は安全ではありません。

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

次の結果も正しくありません。

> 9007199254740995 - 10
9007199254740986

今回は結果は安全ですが、オペランドの1つは安全ではありません。

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

したがって、整数演算子opを適用した結果は、すべてのオペランドと結果が安全な場合にのみ正しいことが保証されます。より正式には

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

a op bが正しい結果であることを意味します。

マスク（第2オペランド）が0の場合、ビットは変更されず、結果は第1オペランド（符号付き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

ビットごとのORで機能したのと同じトリックがシフト演算子でも機能します。0ビットだけシフトすると、シフト演算の結果は、第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関数の1つを、場合によってはMath.abs()に追加して使用すると、より分かりやすく、より良い選択肢と言えるでしょう。

基数の範囲は2 ≤ radix ≤ 36です。これは、解析する数値の基数を決定します。基数が10より大きい場合、0～9に加えて、文字が数字として使用されます（大文字と小文字は区別されません）。

radixが省略されている場合、strが「0x」または「0X」で始まる場合を除き、10と見なされます。その場合、radixは16（16進数）に設定されます。

> parseInt('0xA')
10

radixが既に16の場合、16進数のプレフィックスは省略可能です。

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

これまでのところ、ECMAScript仕様に従ったparseInt()の動作について説明しました。さらに、一部のエンジンでは、strがゼロで始まる場合、基数を8に設定します。

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

したがって、基数を常に明示的に指定し、常に2つの引数で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を参照）による文字列の解析はそれほど寛容ではありませんが、非整数になる可能性があります。

2進数の2進補数（または逆数）を計算する一般的な2つの方法は次のとおりです。

32ビット整数には明示的な符号がありませんが、負の数をエンコードすることは可能です。例えば、−1は1の2の補数としてエンコードできます。結果に1を加えると0になります（32ビット以内）。正の数と負の数の境界は流動的です。4294967295 (2³²−1)と−1はここで同じ整数です。しかし、そのような整数をJavaScriptの数値（明示的な符号を持つ）に変換する際、符号を決定する必要があります。そのため、符号付き32ビット整数は2つのグループに分けられます。

最上位ビットはしばしば符号ビットと呼ばれます。従って、符号付き32ビット整数として解釈された4294967295は、JavaScriptの数値に変換されると−1になります。

> ToInt32(4294967295)
-1

ToInt32()については、ビット演算子による32ビット整数で説明しています。

以下の例では、次の2つの操作を用いて2進数を使用します。

基数10の場合、toString()は、2つの場合に指数表記（小数点の前に1桁）を使用します。まず、数値の小数点の前に21桁以上ある場合。

> 1234567890123456789012
1.2345678901234568e+21
> 123456789012345678901
123456789012345680000

次に、数値が0.で始まり、その後に5つ以上の0と0以外の数字が続く場合。

> 0.0000003
3e-7
> 0.000003
0.000003

その他の場合、固定小数点表記が使用されます。