JavaScript
Встроенные константы

Операции, возвращающие NaN

Математические операции над значениями, отличными от чисел, возвращают NaN.

"a" + 1
"b" * 3
"cde" - "e"
[1, 2, 3] * 2

Исключение: массивы с одним номером.

[2] * [3]  // Returns 6

Кроме того, помните, что оператор + конкатенирует строки.

"a" + "b"  // Returns "ab"

Деление нуля на ноль возвращает NaN .

0 / 0         // NaN

Примечание. В математике вообще (в отличие от программирования JavaScript) деление на ноль невозможно.

Математические функции библиотеки, возвращающие NaN

Как правило, Math функции, заданные нечисловыми аргументами, возвращают NaN.

Math.floor("a")

Квадратный корень отрицательного числа возвращает NaN, потому что Math.sqrt не поддерживает мнимые или комплексные числа.

Math.sqrt(-1)

Тестирование для NaN с использованием isNaN ()

window.isNaN()

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

^{(*) Метод «преобразования» не так прост, см. ECMA-262 18.2.3 для подробного объяснения алгоритма.}

Эти примеры помогут вам лучше понять поведение isNaN() :

isNaN(NaN);          // true
isNaN(1);            // false: 1 is a number
isNaN(-2e-4);        // false: -2e-4 is a number (-0.0002) in scientific notation
isNaN(Infinity);     // false: Infinity is a number
isNaN(true);         // false: converted to 1, which is a number
isNaN(false);        // false: converted to 0, which is a number
isNaN(null);         // false: converted to 0, which is a number
isNaN("");           // false: converted to 0, which is a number
isNaN(" ");          // false: converted to 0, which is a number
isNaN("45.3");       // false: string representing a number, converted to 45.3
isNaN("1.2e3");      // false: string representing a number, converted to 1.2e3
isNaN("Infinity");   // false: string representing a number, converted to Infinity
isNaN(new Date);     // false: Date object, converted to milliseconds since epoch
isNaN("10$");        // true : conversion fails, the dollar sign is not a digit
isNaN("hello");      // true : conversion fails, no digits at all
isNaN(undefined);    // true : converted to NaN
isNaN();             // true : converted to NaN (implicitly undefined)
isNaN(function(){}); // true : conversion fails
isNaN({});           // true : conversion fails
isNaN([1, 2]);       // true : converted to "1, 2", which can't be converted to a number

Этот последний немного сложнее: проверка наличия Array NaN . Для этого конструктор Number() сначала преобразует массив в строку, а затем в число; это причина, почему isNaN([]) и isNaN([34]) возвращают false , но isNaN([1, 2]) и isNaN([true]) возвращают true : поскольку они преобразуются в "" , "34" , "1,2" и "true" соответственно. В общем случае массив считается NaN by isNaN() если только он содержит только один элемент, строковое представление которого может быть преобразовано в действительное число .

// The one and only 
Number.isNaN(NaN);          // true

// Numbers
Number.isNaN(1);            // false
Number.isNaN(-2e-4);        // false
Number.isNaN(Infinity);     // false

// Values not of type number
Number.isNaN(true);         // false
Number.isNaN(false);        // false
Number.isNaN(null);         // false
Number.isNaN("");           // false
Number.isNaN(" ");          // false
Number.isNaN("45.3");       // false
Number.isNaN("1.2e3");      // false
Number.isNaN("Infinity");   // false
Number.isNaN(new Date);     // false
Number.isNaN("10$");        // false
Number.isNaN("hello");      // false
Number.isNaN(undefined);    // false
Number.isNaN();             // false
Number.isNaN(function(){}); // false
Number.isNaN({});           // false
Number.isNaN([]);           // false
Number.isNaN([1]);          // false
Number.isNaN([1, 2]);       // false
Number.isNaN([true]);       // false

ноль

null используется для представления преднамеренного отсутствия значения объекта и является примитивным значением. В отличие от undefined , это не свойство глобального объекта.

Он равен undefined но не идентичному ему.

null == undefined; // true
null === undefined; // false

Внимание: Условия typeof null является 'object' .

typeof null; // 'object';

Чтобы правильно проверить, является ли значение null , сравните его со строгим оператором равенства

var a = null;

a === null; // true

undefined и null

На первый взгляд может показаться, что null и undefined в основном одинаковы, однако существуют тонкие, но важные различия.

undefined - отсутствие значения в компиляторе, потому что там, где оно должно быть значением, его не было, как в случае с неназначенной переменной.

• undefined - глобальное значение, которое представляет собой отсутствие назначенного значения.
  • typeof undefined === 'undefined'
• null - это объект, который указывает, что переменной явно присвоено значение «нет значения».
  • typeof null === 'object'

Установка переменной в undefined означает, что переменная эффективно не существует. Некоторые процессы, такие как сериализация JSON, могут отделять undefined свойства от объектов. Напротив, null свойства указывают, что они будут сохранены, поэтому вы можете явно передать концепцию «пустого» свойства.

Нижеследующие значения undefined :

• Переменная, когда объявляется, но не назначается значение (т. Е. Определено)

  • let foo;
    console.log('is undefined?', foo === undefined);
    // is undefined? true
    

• Доступ к значению свойства, которое не существует

  • let foo = { a: 'a' };
    console.log('is undefined?', foo.b === undefined);
    // is undefined? true
    

• Возвращаемое значение функции, которая не возвращает значение

  • function foo() { return; }
    console.log('is undefined?', foo() === undefined);
    // is undefined? true
    

• Значение аргумента функции, которое объявлено, но не указано в вызове функции

  • function foo(param) { 
      console.log('is undefined?', param === undefined);
    }
    foo('a');
    foo();
    // is undefined? false
    // is undefined? true
    

undefined также является свойством глобального объекта window .

// Only in browsers
console.log(window.undefined); // undefined
window.hasOwnProperty('undefined'); // true    

Бесконечность и бесконечность

1 / 0; // Infinity
// Wait! WHAAAT?

Infinity является свойством глобального объекта (следовательно, глобальной переменной), который представляет собой математическую бесконечность. Это ссылка на Number.POSITIVE_INFINITY

Он больше любого другого значения, и вы можете получить его путем деления на 0 или путем вычисления выражения числа, которое настолько велико, что переполняется. Это на самом деле означает, что в JavaScript нет деления на 0 ошибок, есть Infinity!

Существует также -Infinity которая является математической отрицательной бесконечностью, и она ниже любой другой ценности.

Чтобы получить -Infinity вы отрицаете Infinity или получаете ссылку на нее в Number.NEGATIVE_INFINITY .

- (Infinity); // -Infinity

Теперь давайте немного повеселимся с примерами:

Infinity > 123192310293; // true
-Infinity < -123192310293; // true
1 / 0; // Infinity
Math.pow(123123123, 9123192391023); // Infinity
Number.MAX_VALUE * 2; // Infinity
23 / Infinity; // 0
-Infinity; // -Infinity
-Infinity === Number.NEGATIVE_INFINITY; // true
-0; // -0 , yes there is a negative 0 in the language
0 === -0; // true
1 / -0; // -Infinity
1 / 0 === 1 / -0; // false
Infinity + Infinity; // Infinity

var a = 0, b = -0;

a === b; // true
1 / a === 1 / b; // false

// Try your own!

NaN

NaN означает «Не номер». Когда математическая функция или операция в JavaScript не может вернуть определенный номер, вместо этого она возвращает значение NaN .

Это свойство глобального объекта, а ссылка на Number.NaN

window.hasOwnProperty('NaN'); // true
NaN; // NaN

Возможно, смутно, NaN по-прежнему считается числом.

typeof NaN; // 'number'

Не проверяйте NaN с помощью оператора равенства. isNaN этого смотрите isNaN .

NaN == NaN  // false
NaN === NaN // false

Числовые константы

Конструктор Number имеет некоторые встроенные константы, которые могут быть полезны

Number.MAX_VALUE;          // 1.7976931348623157e+308
Number.MAX_SAFE_INTEGER;   // 9007199254740991

Number.MIN_VALUE;          // 5e-324
Number.MIN_SAFE_INTEGER;   // -9007199254740991

Number.EPSILON;            // 0.0000000000000002220446049250313

Number.POSITIVE_INFINITY;  // Infinity
Number.NEGATIVE_INFINITY;  // -Infinity

Number.NaN;                // NaN

Во многих случаях различные операторы в Javascript будут разбиваться со значениями вне диапазона ( Number.MIN_SAFE_INTEGER , Number.MAX_SAFE_INTEGER )

Обратите внимание , что Number.EPSILON представляет различные между одним и наименьшим Number больше единицы, и , таким образом , минимально возможного различия между двумя различными Number значений. Одна из причин использования этого объясняется тем, как номера хранятся в JavaScript см. Проверка равенства двух чисел