use-isnan

Требует вызова isNaN() при проверке на NaN

В JavaScript NaN — это специальное значение типа Number. Оно используется для представления любого из значений «не число», представленных форматом с плавающей запятой двойной точности (64 бита), определённым стандартом IEEE для арифметики с плавающей запятой.

Поскольку NaN в JavaScript уникально тем, что не равно ничему, даже самому себе, результаты сравнений с NaN могут сбивать с толку:

• NaN === NaN или NaN == NaN дают результат false
• NaN !== NaN или NaN != NaN дают результат true

Поэтому для проверки, является ли значение NaN, используйте Number.isNaN() или глобальные функции isNaN().

Подробности правила

Это правило запрещает сравнения с 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 (по умолчанию) дополнительно запрещает case NaN и switch(NaN) в инструкциях switch.
• "enforceForIndexOf": true дополнительно запрещает использование методов indexOf и lastIndexOf с NaN. Значение по умолчанию — false, то есть по умолчанию это правило не предупреждает о вызовах методов indexOf(NaN) или lastIndexOf(NaN).

enforceForSwitchCase

Инструкция switch внутри использует сравнение === для сопоставления значения выражения с вариантом case. Поэтому она никогда не может сопоставить case NaN. Кроме того, switch(NaN) никогда не может сопоставляться с вариантом case.

Примеры неправильного кода для этого правила, если параметр "enforceForSwitchCase" установлен в значение true (по умолчанию):

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

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

switch(NaN){casea:bar();break;caseb:baz();break;// ...}

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

switch(Number.NaN){casea:bar();break;caseb: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.

Установите "enforceForIndexOf" в значение true, если хотите, чтобы это правило сообщало о вызовах методов indexOf(NaN) и lastIndexOf(NaN).

Примеры неправильного кода для этого правила, если параметр "enforceForIndexOf" установлен в значение 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);

Примеры правильного кода для этого правила, если параметр "enforceForIndexOf" установлен в значение 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);

Известные ограничения

Этот параметр проверяет методы с указанными именами, даже если объект, которому принадлежит метод, не является массивом.

Версия

Это правило добавлено в ESLint v0.0.6.

Ресурсы

• Исходный код правила
• Исходный код тестов