use-isnan

檢查 NaN 時，要求呼叫 isNaN()

✅

在設定檔中使用 @eslint/js 的 recommended 設定會啟用此規則

💡

此規則回報的一些問題可由編輯器建議手動修正

在 JavaScript 中，NaN 是 Number 類型的一個特殊值。它用於表示 IEEE 二進制浮點算術標準所指定的雙精度 64 位格式所表示的任何「非數值」。

因為 NaN 在 JavaScript 中是獨一無二的，不等於任何東西（包括它自己），所以與 NaN 的比較結果令人困惑

NaN === NaN 或 NaN == NaN 的求值結果為 false
NaN !== NaN 或 NaN != NaN 的求值結果為 true

因此，請使用 Number.isNaN() 或全域 isNaN() 函數來測試值是否為 NaN。

規則詳情

此規則不允許與 NaN 進行比較。

此規則的錯誤程式碼範例

在遊樂場中開啟

/*eslint use-isnan: "error"*/

if (foo == NaN) {
    // ...
}

if (foo != NaN) {
    // ...
}

if (foo == Number.NaN) {
    // ...
}

if (foo != Number.NaN) {
    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

此規則的正確程式碼範例

在遊樂場中開啟

/*eslint use-isnan: "error"*/

if (isNaN(foo)) {
    // ...
}

if (!isNaN(foo)) {
    // ...
}
1
2
3
4
5
6
7
8
9

選項

此規則有一個物件選項，包含兩個選項

"enforceForSwitchCase": true（預設）另外不允許在 switch 陳述式中使用 case NaN 和 switch(NaN)。
"enforceForIndexOf": true 另外不允許使用 NaN 的 indexOf 和 lastIndexOf 方法。預設值為 false，這表示此規則預設不會警告 indexOf(NaN) 或 lastIndexOf(NaN) 方法呼叫。

enforceForSwitchCase

switch 陳述式內部使用 === 比較來將運算式的值與 case 子句匹配。因此，它永遠無法匹配 case NaN。此外，switch(NaN) 永遠無法匹配任何 case 子句。

當 "enforceForSwitchCase" 選項設定為 true (預設) 時，此規則的錯誤程式碼範例

在遊樂場中開啟

/*eslint use-isnan: ["error", {"enforceForSwitchCase": true}]*/

switch (foo) {
    case NaN:
        bar();
        break;
    case 1:
        baz();
        break;
    // ...
}

switch (NaN) {
    case a:
        bar();
        break;
    case b:
        baz();
        break;
    // ...
}

switch (foo) {
    case Number.NaN:
        bar();
        break;
    case 1:
        baz();
        break;
    // ...
}

switch (Number.NaN) {
    case a:
        bar();
        break;
    case b:
        baz();
        break;
    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

當 "enforceForSwitchCase" 選項設定為 true (預設) 時，此規則的正確程式碼範例

在遊樂場中開啟

/*eslint use-isnan: ["error", {"enforceForSwitchCase": true}]*/

if (Number.isNaN(foo)) {
    bar();
} else {
    switch (foo) {
        case 1:
            baz();
            break;
        // ...
    }
}

if (Number.isNaN(a)) {
    bar();
} else if (Number.isNaN(b)) {
    baz();
} // ...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

當 "enforceForSwitchCase" 選項設定為 false 時，此規則的正確程式碼範例

在遊樂場中開啟

/*eslint use-isnan: ["error", {"enforceForSwitchCase": false}]*/

switch (foo) {
    case NaN:
        bar();
        break;
    case 1:
        baz();
        break;
    // ...
}

switch (NaN) {
    case a:
        bar();
        break;
    case b:
        baz();
        break;
    // ...
}

switch (foo) {
    case Number.NaN:
        bar();
        break;
    case 1:
        baz();
        break;
    // ...
}

switch (Number.NaN) {
    case a:
        bar();
        break;
    case b:
        baz();
        break;
    // ...
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

enforceForIndexOf

以下方法會在內部使用 === 比較，將給定值與陣列元素進行匹配

因此，對於任何陣列 foo，foo.indexOf(NaN) 和 foo.lastIndexOf(NaN) 都會永遠返回 -1。

如果您希望此規則回報 indexOf(NaN) 和 lastIndexOf(NaN) 方法呼叫，請將 "enforceForIndexOf" 設定為 true。

當 "enforceForIndexOf" 選項設定為 true 時，此規則的錯誤程式碼範例

在遊樂場中開啟

/*eslint use-isnan: ["error", {"enforceForIndexOf": true}]*/

var hasNaN = myArray.indexOf(NaN) >= 0;

var firstIndex = myArray.indexOf(NaN);

var lastIndex = myArray.lastIndexOf(NaN);

var indexWithSequenceExpression = myArray.indexOf((doStuff(), NaN));

var firstIndexFromSecondElement = myArray.indexOf(NaN, 1);

var lastIndexFromSecondElement = myArray.lastIndexOf(NaN, 1);
1
2
3
4
5
6
7
8
9
10
11
12
13

當 "enforceForIndexOf" 選項設定為 true 時，此規則的正確程式碼範例

在遊樂場中開啟

/*eslint use-isnan: ["error", {"enforceForIndexOf": true}]*/

function myIsNaN(val) {
    return typeof val === "number" && isNaN(val);
}

function indexOfNaN(arr) {
    for (var i = 0; i < arr.length; i++) {
        if (myIsNaN(arr[i])) {
            return i;
        }
    }
    return -1;
}

function lastIndexOfNaN(arr) {
    for (var i = arr.length - 1; i >= 0; i--) {
        if (myIsNaN(arr[i])) {
            return i;
        }
    }
    return -1;
}

var hasNaN = myArray.some(myIsNaN);

var hasNaN = indexOfNaN(myArray) >= 0;

var firstIndex = indexOfNaN(myArray);

var lastIndex = lastIndexOfNaN(myArray);

// ES2015
var hasNaN = myArray.some(Number.isNaN);

// ES2015
var firstIndex = myArray.findIndex(Number.isNaN);

// ES2016
var hasNaN = myArray.includes(NaN);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

已知限制

此選項會檢查具有指定名稱的方法，*即使* 具有該方法的物件*不是* 陣列。

版本

此規則在 ESLint v0.0.6 中引入。

資源

編輯此頁面