Почему typeof NaN возвращает «число»?

https://stackoverflow.com/questions/2801601

25-09-2019
|

Вопрос

Просто из любопытства.

Это кажется не очень логичным typeof NaN это число.Как NaN === NaN или NaN == NaN кстати, возвращает false.Это одна из особенностей javascript или для этого есть причина?

Редактировать:спасибо за ваши ответы.Однако не так-то просто прийти в себя.Читая ответы и вики я понял больше, но всё равно предложение типа

Сравнение с NaN всегда возвращает неупорядоченный результат, даже при сравнении с самим собой.Предикаты сравнения либо сигнализируют, либо не сигнализируют, версии сигнализации сигнализируют о недопустимом исключении для таких сравнений.Предикаты равенства и неравенства не передают сигналы, поэтому x = x, возвращающий false, можно использовать для проверки того, является ли x тихим NaN.

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

Решение

Это значит не число. Это не особенность JavaScript, а принцип общего информатика.

От http://en.wikipedia.org/wiki/nan.:

Есть три вида операции, которые возвращают NAN:

Операции с нан как минимум один операнд

Неопределенные формы

Отделы 0/0, ∞ / ∞, ∞ / -∞, -∞ / ∞ и ∞ / -∞

Мультипликации 0 × ∞ и 0 × -∞

Сила 1 ^ ∞

Дополнения ∞ + (-∞), (-∞) + ∞ и эквивалентные вычитания.

Реальные операции со сложными результатами:

Квадратный корень отрицательного числа

Логарифм отрицательного числа

Тангенс нечетного множества 90 градусов (или π / 2 радианов)

Обратный синус или косинус числа, который меньше, чем -1 или выше +1.

Все эти значения могут быть не одинаковыми. Простой тест для NAN является тестирование value == value неверно.

Другие советы

Хорошо, NaN все еще числовой тип, Несмотря на тот факт, что он на самом деле стоит за не-ряд :-)

NaN Точно означает, что конкретное значение не может быть представлено в пределах числовых типов (хотя, что можно сказать на все числа, которые должны быть округлены, чтобы соответствовать, но NaN это особый случай).

Специфичный NaN не считается равным другому NaN Потому что они могут быть разными ценностями. Однако, NaN все еще такой тип, как 2718 или 31415.

Что касается вашего обновления вопроса, чтобы объяснить в Условиях Мэймана:

Сравнение с NAN всегда возвращает неупорядоченный результат даже при сравнении с собой. Предикаты сравнения являются либо сигнализация, либо несигнализирующие, сигнализирующие версии сигнализируют неверный исключение для таких сравнений. Предикаты равенства и неравенства не сигнализируются так, чтобы X = X возвращающий ложь можно использовать для проверки, если X тихий нан.

Все это средство (разбито на части):

Сравнение с NAN всегда возвращает неупорядоченный результат даже при сравнении с собой.

В основном, а NaN не равно любому другому номеру, включая другой NaN, и даже в том числе сам.

Предикаты сравнения являются либо сигнализация, либо несигнализирующие, сигнализирующие версии сигнализируют неверный исключение для таких сравнений.

Пытаясь сделать сравнение (меньше, больше, чем и т. Д.) Операции между NaN И еще одно число может привести к выдаче исключения (сигнализация) или просто получать ложь в качестве результата (несигнализированная или тихая).

Предикаты равенства и неравенства не сигнализируются так, чтобы X = X возвращающий ложь можно использовать для проверки, если X тихий нан.

Тесты на равенство (равное, не равное) никогда не сигнализируются, поэтому их использование не вызывает исключения. Если у вас есть обычный номер x, тогда x == x всегда будет правдой. Если x это NaN, тогда x == x всегда будет ложным. Это дает вам способ обнаружить NaN легко (тихо).

Стандарт Ecmascript (JavaScript) указывает, что Numbers являются IEEE 754. поплавки, которые включают NaN как возможное значение.

ECMA 262 5E Раздел 4.3.19: Числовое значение

Примитивное значение, соответствующее двойной точности 64-битного двоичного формата IEEE 754 значения.

ECMA 262 5E Раздел 4.3.23: Нан

Значение номера, которое является значением IEEE 754 "NO-A-NOME".

IEEE 754. на Википедии

Стандарт IEEE для арифметики с плавающей точкой является техническим стандартом, установленным Институтом инженеров электрических и электроники и наиболее широко используемым стандартом для вычисления с плавающей точкой [...

Стандарт определяет

арифметические форматы: наборы бинарных и десятичных данных с плавающей запятой, которые состоят из конечных чисел (включая подписанные нули и субнормальные числа), зажиманиями и Специальный «не число» ценности (назы)

[...]

typeof NaN возвращает 'number' потому что:

Спецификация ECMAScript говорит, что тип Number включает NaN:

4.3.20 Тип номера

Набор всех возможных значений числа, включая специальные значения «не номера» (NAN), положительную бесконечность и отрицательную бесконечность

Так typeof возвращает соответственно:

11.4.3 Тип оператора

Производство УнарноеВыражение : typeof УнарноеВыражение оценивается следующим образом:

Позволять вал быть результатом оценки УнарноеВыражение.
Если Тип(вал) является Ссылка, затем
1. Если Исунресолваблессылка(вал) является истинный, возвращаться "undefined".
2. Позволять вал быть Получить значение(вал).
Вернуть строку, определенную Тип(вал) согласно таблице 20.

                Table 20 — typeof Operator Results
==================================================================
|        Type of val         |              Result               |
==================================================================
| Undefined                  | "undefined"                       |
|----------------------------------------------------------------|
| Null                       | "object"                          |
|----------------------------------------------------------------|
| Boolean                    | "boolean"                         |
|----------------------------------------------------------------|
| Number                     | "number"                          |
|----------------------------------------------------------------|
| String                     | "string"                          |
|----------------------------------------------------------------|
| Object (native and does    | "object"                          |
| not implement [[Call]])    |                                   |
|----------------------------------------------------------------|
| Object (native or host and | "function"                        |
| does implement [[Call]])   |                                   |
|----------------------------------------------------------------|
| Object (host and does not  | Implementation-defined except may |
| implement [[Call]])        | not be "undefined", "boolean",    |
|                            | "number", or "string".            |
------------------------------------------------------------------

Такое поведение соответствует Стандарт IEEE для арифметики с плавающей запятой (IEEE 754):

4.3.19 Числовое значение

Примитивное значение, соответствующее 64-разрядному бинадному формату двойного определения IEEE 754

4.3.23 НЭН

числовое значение, которое является значением IEEE 754 «Не-число»

8.5 Тип номера

Тип Number имеет ровно 18437736874454810627 (т. е. 2⁵³−2⁶⁴ 3) значения, представляющие двойную точность 64-битный формат IEEE 754 значения, указанные в стандарте IEEE для бинарных плавающих точек Арифметические, за исключением того, что 9007199254740990 (то есть, 2⁵³−2) отдельные Значения «Not-a-Number» стандарта IEEE представлены в ECMAScript как единый специальный НЭН ценить.(Обратите внимание, что НЭН значение производится программным выражением NaN.)

NAN является действительным значением с плавающей запятой (http://en.wikipedia.org/wiki/nan.)

и nan === NAN неверно, потому что они не обязательно одинаковы не числа

NaN != NaN Потому что они не нужны одинаково не число. Таким образом, это имеет много смысла ... Также зачем плавает как +0,00 и -0,00, которые не одинаковы. Округление может сделать то, что они на самом деле не ноль.

Что касается типа, это зависит от языка. И большинство языков скажут, что NAN - это поплавок, двойной или номер в зависимости от того, как они классифицируют ... Я знаю без языков, которые скажут, что это неизвестный тип или нулевой.

NaN Стенды Не число. Отказ Это значение числовых типов данных (обычно типов плавающих точек, но не всегда), которая представляет собой результат недействительной операции, такой как разделитель на ноль.

Хотя его имена говорится, что это не число, тип данных, используемый для его удержания, является числовым типом. Так что в JavaScript, спрашивая на данных DataType NaN вернусь number (так как alert(typeof(NaN)) четко демонстрирует).

JavaScript использует NAN, чтобы представлять все, что он сталкивается с тем, что не может быть представляется другим способом его спецификаций. Это не значит, что это не число. Это просто самый простой способ описать встречу. NAN означает, что это объект, который относится к нему, не может быть представлен любым другим способом JavaScript. Для всех практических целей это «неизвестно». Быть «неизвестным» не может сказать вам, что это ничем, даже если он сам. Это даже не объект, на который он назначен. Он может только сказать вам, что это не так, и нет несна или ничего не может быть описано только математически на языке программирования. Так как математика о количестве, JavaScript представляет собой нечто как нан. Это не значит, что это не число. Это означает, что мы не можем прочитать это каким-либо другим способом, имеющим смысл. Вот почему он даже не может равен себя. Потому что это не так.

Лучшее имя для NaN, описывая его значение точнее и менее смущенно, будет Численное исключение. Отказ Это действительно еще один вид объекта исключения, замаскированный как имеющий примитивный тип (по языковому дизайну), где на то же самое не рассматривается как примитив в его ложном самостоятельном сравнении. Откуда путаница. И до тех пор, пока язык «не уйдет» на выбор между надлежащий объект исключения а также примитивный цифр, Путаница останется.

Печально известное не равенство NaN к себе, оба == а также === является проявлением запутанного дизайна, заставляющего этот объект исключения в том, чтобы стать примитивным типом. Это разбивает фундаментальный принцип, что Примитив однозначно определяется его ценностью. Отказ Если NaN предпочтительно, чтобы рассматриваться как исключение (из которых могут быть разные виды), то он не должен быть «продан» как примитив. И если он хочет быть примитивным, этот принцип должен держать. Пока она сломана, как у нас в JavaScript, и мы не можем решить между ними, путаница, ведущая к ненужной когнитивной нагрузке для всех вовлеченных, останется. Что, однако, действительно легко исправить, просто сделав выбор между двумя:

либо сделать NaN Специальный объект исключения, содержащий полезную информацию о том, как возникла исключение, в отличие от того, что выбросит эту информацию, как то, что в настоящее время реализуется, ведущая к сложнее для отладки;
или сделать NaN сущность примитивного типа number (Это может быть менее смущенно называется «числовым»), и в этом случае он должен быть равен себе и не может содержать какую-либо другую информацию; Последнее явно не является низшим выбором.

Единственное мышеное преимущество форсирования NaN в number Тип способен бросить его обратно в любое числовое выражение. Который, однако, делает его хрупким выбором, потому что результат любого числового выражения, содержащего NaN будет либо будет NaN, или приводя к непредсказуемым результатам, таким как NaN < 0 Оценка false, то есть возвращение boolean вместо того, чтобы держать исключение.

И даже если «вещи так, как они есть», ничто не мешает нам сделать это четкое различие для себя, чтобы помочь сделать наш код более предсказуемым и легким отладочным. На практике это означает выявление этих исключений и иметь дело с ними как исключения. Что, к сожалению, означает больше кода, но надеюсь, будет смягчаться инструментами, такими как Tymdscript flowtype.

А потом у нас грязно Тихие против шумных сигналов NaN различие. Отказ Что действительно о том, насколько связаны исключения, а не сами исключения, и ничего отличающегося от других исключений.

По аналогии, Infinity а также +Infinity элементы Числовый тип возникающий в Расширение реальной линии Но они не настоящие числа. Математически их можно представить последовательностями реальных чисел, сходящихся к либо + или -Infinity.

Это просто потому, что NaN Это свойство номера объекта в JS, он не имеет ничего общего с этим числом.

Лучший способ подумать о том, что это не известный количество. Вот почему NAN! = NAN, потому что каждое значение NAN представляет собой какой-то уникальный неизвестный номер. Назы необходимы, потому что номера с плавающей точкой имеют ограниченный диапазон значений. В некоторых случаях округление происходит, когда нижние биты теряются, что приводит к тому, что кажется ерундой, как 1,0 / 11 * 11! = 1,0. Действительно большие значения, которые больше являются назами с бесконечностью, являющимся идеальным примером.

Учитывая, что у нас есть только десять пальцев любые попытки показать значения, превышающие 10, нельзя, что означает, что такие значения должны быть называющимися, потому что мы потеряли истинное значение этого более 10 ценностей. То же самое относится и к значениям плавающих точек, где значение превышает пределы того, что можно проводить в поплавке.

Потому что NAN является числовым типом данных.

NaN является числом с точки зрения типа, но не является обычным числом, таким как 1, 2 или 329131.Имя «Не число» относится к тому факту, что представленное значение является специальным и относится к домену спецификации формата IEEE, а не к домену языка javascript.

При использовании jQuery я предпочитаю isNumeric Перевернуть тип:

console.log($.isNumeric(NaN));  // returns false
console.log($.type(NaN));       // returns number

http://api.jquery.com/jquery.isnumeric/

JavaScript имеет только один числовой тип данных, который является стандартным 64-битной двойной точностью. Все двойное. Нан - это особое значение двойного, но это удваивает, тем не менее.

Все это parseInt делает это «отличить» вашу строку в числовой тип данных, поэтому результат всегда "количество"; Только если исходная строка не была приспособлена, его значение будет NAN.

NAN все еще является числовым типом, но он представляет значение, которое не может представлять действительный номер.

Мы могли бы утверждать, что NAN является специальным объектом дела. В этом случае объект NAN представляет число, которое не имеет математического смысла. Есть некоторые другие особые предметы объекта в математике, как бесконечно и так далее.

Вы все еще можете сделать некоторые расчеты с ним, но это даст странное поведение.

Больше информации здесь: http://www.concentric.net/~ttwang/tech/javafloat.htm. (Java на основе, а не JavaScript)

Вы должны любить JavaScript. У него есть некоторые интересные маленькие причуды.

http://wtfjs.com/page/13.

Большинство из этих щипцов можно объяснить, если вы перестанете работать в логике, или если вы немного узнаете о теории номера, но тем не менее они все еще могут уловить вас, если вы не знаете о них.

Кстати, я рекомендую читать остальные http://wtfjs.com/ - Есть гораздо более интересные quirks, чем этот можно найти!

Значение NAN действительно является числом .Nan, если вы спрашиваете, если это число, это скажет да. Вы сделали правильную вещь, используя вызов isnan ().

Для получения информации NAN также может быть возвращена операциями по номерам, которые не определены, как подразделения нолью или квадратным корнем отрицательного числа.

Пример

Представьте, что мы преобразуем строку на номер:

Number("string"); // returns NaN

Мы изменили тип данных на номер, но его значение не является числом!

Это особое значение типа номера, что и положительница_infinity

Почему? По дизайну

Лицензировано под: CC-BY-SA с атрибуция

Не связан с StackOverflow