use-isnan

检查 NaN 时需要调用 isNaN()

在 JavaScript 中，NaN 是 Number 类型的一个特殊值。它用于表示由 IEEE 二进制浮点算术标准规定的双精度 64 位格式所表示的任何“非数字”值。

🌐 In JavaScript, NaN is a special value of the Number type. It’s used to represent any of the “not-a-number” values represented by the double-precision 64-bit format as specified by the IEEE Standard for Binary Floating-Point Arithmetic.

因为 NaN 在 JavaScript 中是独一无二的，它不等于任何东西，包括它自己，所以与 NaN 的比较结果令人困惑：

🌐 Because NaN is unique in JavaScript by not being equal to anything, including itself, the results of comparisons to NaN are confusing:

• NaN === NaN 或 NaN == NaN 的值为 false
• NaN !== NaN 或 NaN != NaN 的结果是 true

因此，使用 Number.isNaN() 或全局 isNaN() 函数来测试某个值是否为 NaN。

🌐 Therefore, use Number.isNaN() or global isNaN() functions to test whether a value is NaN.

规则详情

🌐 Rule Details

此规则不允许与 NaN 进行比较。

🌐 This rule disallows comparisons to NaN.

此规则的错误代码示例：

🌐 Examples of incorrect code for this rule:

/*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

符合此规则的正确代码示例：

🌐 Examples of correct code for this rule:

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

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

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

选项

🌐 Options

此规则有一个对象选项，有两个选项：

🌐 This rule has an object option, with two options:

• "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 子句。

🌐 The switch statement internally uses the === comparison to match the expression’s value to a case clause. Therefore, it can never match case NaN. Also, switch(NaN) can never match a case clause.

在 "enforceForSwitchCase" 选项设置为 true（默认）时，此规则的 错误 代码示例：

🌐 Examples of incorrect code for this rule with "enforceForSwitchCase" option set to true (default):

/*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（默认）时，此规则的 正确 代码示例：

🌐 Examples of correct code for this rule with "enforceForSwitchCase" option set to true (default):

/*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 时的正确代码示例：

🌐 Examples of correct code for this rule with "enforceForSwitchCase" option set to 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

以下方法在内部使用 === 比较来将给定值与数组元素进行匹配：

🌐 The following methods internally use the === comparison to match the given value with an array element:

• Array.prototype.indexOf
• Array.prototype.lastIndexOf

因此，对于任何数组 foo，foo.indexOf(NaN) 和 foo.lastIndexOf(NaN) 总是会返回 -1。

🌐 Therefore, for any array foo, foo.indexOf(NaN) and foo.lastIndexOf(NaN) will always return -1.

如果你希望此规则报告 indexOf(NaN) 和 lastIndexOf(NaN) 方法调用，请将 "enforceForIndexOf" 设置为 true。

🌐 Set "enforceForIndexOf" to true if you want this rule to report indexOf(NaN) and lastIndexOf(NaN) method calls.

在 "enforceForIndexOf" 选项设置为 true 时，此规则的 错误 代码示例：

🌐 Examples of incorrect code for this rule with "enforceForIndexOf" option set to true:

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

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

const firstIndex = myArray.indexOf(NaN);

const lastIndex = myArray.lastIndexOf(NaN);

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

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

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

这个规则在 "enforceForIndexOf" 选项设置为 true 时的正确代码示例：

🌐 Examples of correct code for this rule with "enforceForIndexOf" option set to true:

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

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

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

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

const hasNaN = myArray.some(myIsNaN);

const hasNaN1 = indexOfNaN(myArray) >= 0;

const firstIndex = indexOfNaN(myArray);

const lastIndex = lastIndexOfNaN(myArray);

// ES2015
const hasNaN2 = myArray.some(Number.isNaN);

// ES2015
const firstIndex1 = myArray.findIndex(Number.isNaN);

// ES2016
const hasNaN3 = 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

已知限制

🌐 Known Limitations

此选项会检查具有给定名称的方法，即使拥有该方法的对象不是数组。

🌐 This option checks methods with the given names, even if the object which has the method is not an array.

版本

此规则是在 ESLint v0.0.6 中引入。

资源

• 规则源码
• 测试源码