# use-isnan

检查 NaN 时需要调用 isNaN()

配置文件中的 "extends": "eslint:recommended" 属性启用了该规则

在 JavaScript 中，NaN 是 Number 类型的一个特殊值。它用于表示由 IEEE 二进制浮点算术标准指定的双精度 64 位格式表示的任何 "not-a-number" 值。

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

NaN === NaN 或 NaN == NaN 评估为假
NaN !== NaN 或 NaN != NaN 评估为真

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

# 规则详情

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

此规则的错误代码示例：

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

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

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

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

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

此规则的正确代码示例：

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

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

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

# 选项

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

"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;
    // ...
}

此规则的正确代码示例，其中 "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();
} // ...

此规则的正确代码示例，其中 "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;
    // ...
}

# enforceForIndexOf

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

Array.prototype.indexOf
Array.prototype.lastIndexOf

因此，对于任何数组 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);

此规则的正确代码示例，其中 "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);

# 已知限制

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

← require-atomic-updates valid-typeof →