¿Por qué typeof NaN devuelve 'número'?

Solo por curiosidad.

No parece muy lógico que typeof NaNsea ​​número. Solo como NaN === NaNo NaN == NaNdevolviendo falso, por cierto. ¿Es esta una de las peculiaridades de javascript, o habría una razón para esto?

Editar: gracias por sus respuestas. Sin embargo, no es una cosa fácil tener la cabeza puesta. Leyendo respuestas y la wiki entendí más, pero aún así, una oración como

Una comparación con un NaN siempre devuelve un resultado desordenado, incluso cuando se compara con sí mismo. Los predicados de comparación son señalización o no señalización, las versiones de señalización señalan una excepción no válida para tales comparaciones. Los predicados de igualdad y desigualdad no son señalización, por lo que x = x devuelve falso se puede utilizar para probar si x es un NaN silencioso.

solo mantiene mi cabeza girando. Si alguien puede traducir esto en lenguaje legible para humanos (en lugar de, digamos, matemático), estaría agradecido.

Significa no un número. No es una peculiaridad de javascript, sino un principio informático común.

De http://en.wikipedia.org/wiki/NaN :

Hay tres tipos de operaciones que devuelven NaN:

Operaciones con un NaN como al menos un operando

Formas indeterminadas

• Las divisiones 0/0, ∞ / ∞, ∞ / −∞, −∞ / ∞ y −∞ / −∞
• Las multiplicaciones 0 × ∞ y 0 × −∞
• El poder 1 ^ ∞
• Las adiciones ∞ + (−∞), (−∞) + ∞ y sustracciones equivalentes.

Operaciones reales con resultados complejos:

• La raíz cuadrada de un número negativo
• El logaritmo de un número negativo.
• La tangente de un múltiplo impar de 90 grados (o π / 2 radianes)
• El seno o coseno inverso de un número que es menor que -1 o mayor que +1.

Todos estos valores pueden no ser iguales. Una prueba simple para un NaN es probar que value == valuees falso.

Bueno, NaNsigue siendo un tipo numérico , a pesar del hecho de que en realidad significa Not-A-Number :-)

NaN solo significa que el valor específico no se puede representar dentro de las limitaciones del tipo numérico (aunque eso podría decirse de todos los números que deben redondearse para ajustarse, pero NaN es un caso especial).

Un específico NaNno se considera igual a otro NaNporque pueden ser valores diferentes. Sin embargo, NaNsigue siendo un tipo de número, al igual que 2718 o 31415.

En cuanto a su pregunta actualizada para explicar en términos simples:

Una comparación con un NaN siempre devuelve un resultado desordenado, incluso cuando se compara con sí mismo. Los predicados de comparación son señalización o no señalización, las versiones de señalización señalan una excepción no válida para tales comparaciones. Los predicados de igualdad y desigualdad no son señalización, por lo que x = x devuelve falso se puede utilizar para probar si x es un NaN silencioso.

Todo esto significa es (desglosado en partes):

Una comparación con un NaN siempre devuelve un resultado desordenado, incluso cuando se compara con sí mismo.

Básicamente, a NaNno es igual a ningún otro número, incluido otro NaN, e incluso a sí mismo .

Los predicados de comparación son señalización o no señalización, las versiones de señalización señalan una excepción no válida para tales comparaciones.

Intentar realizar operaciones de comparación (menor que, mayor que, y así sucesivamente) entre un NaNnúmero y otro puede provocar una excepción (señalización) o simplemente obtener un resultado falso (no señalización o silencio).

Los predicados de igualdad y desigualdad no son señalización, por lo que x = x devuelve falso se puede utilizar para probar si x es un NaN silencioso.

Las pruebas de igualdad (igual a, no igual a) nunca son una señal, por lo que su uso no causará una excepción. Si tiene un número regular x, x == xsiempre será cierto. Si xes a NaN, x == xsiempre será falso. Le está dando una manera de detectar NaNfácilmente (en silencio).

El estándar ECMAScript (JavaScript) especifica que Numbersson flotantes IEEE 754 , que incluyen NaNcomo un posible valor.

ECMA 262 5e Sección 4.3.19 : Valor numérico

valor primitivo correspondiente a un formato IEEE 754 de formato binario de 64 bits de doble precisión.

ECMA 262 5e Sección 4.3.23 : NaN

Valor numérico que es un valor IEEE 754 "No es un número".

IEEE 754 en Wikipedia

El estándar IEEE para aritmética de punto flotante es un estándar técnico establecido por el Instituto de Ingenieros Eléctricos y Electrónicos y el estándar más utilizado para el cálculo de punto flotante [...]

El estándar define

• formatos aritméticos : conjuntos de datos de punto flotante binario y decimal, que consisten en números finitos (incluidos ceros con signo y números subnormales), infinitos y valores especiales "no un número" (NaN)

[...]

typeof NaNregresa 'number'porque:

• La especificación ECMAScript dice que el tipo de número incluye NaN:

  4.3.20 Tipo de número

  conjunto de todos los valores numéricos posibles, incluidos los valores especiales de "No es un número" (NaN), infinito positivo e infinito negativo

• Entonces typeofvuelve en consecuencia:

  11.4.3 El tipo de operador

  La producción UnaryExpression : typeof UnaryExpression se evalúa de la siguiente manera:

  1. Sea val el resultado de evaluar UnaryExpression .
  2. Si Tipo ( val ) es Referencia , entonces
     1. Si IsUnresolvableReference ( val ) es verdadero , devuelve "undefined".
     2. Deje que val sea GetValue ( val ).
  3. Devolver una cadena determinada por Type ( val ) de acuerdo con la Tabla 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".            |
  ------------------------------------------------------------------

Este comportamiento está de acuerdo con el estándar IEEE para aritmética de punto flotante (IEEE 754) :

4.3.19 Valor numérico

valor primitivo correspondiente a un formato IEEE 754 de formato binario de doble precisión de 64 bits

4.3.23 NaN

valor de número que es un valor IEEE 754 "No es un número"

8.5 El tipo de número

El tipo de número tiene exactamente 18437736874454810627 (es decir, 2 ⁵³ −2 ⁶⁴ +3) valores, que representan los valores IEEE 754 de formato de doble precisión de 64 bits como se especifica en el estándar IEEE para aritmética de punto flotante binario, excepto que 9007199254740990 ( es decir, 2 ⁵³ −2) valores distintos de "No es un número" del Estándar IEEE están representados en ECMAScript como un único valor especial de NaN . (Tenga en cuenta que el valor NaN es producido por la expresión del programa NaN).

NaN es un valor de coma flotante válido ( http://en.wikipedia.org/wiki/NaN )

y NaN === NaN es falso porque no son necesariamente el mismo no número

NaN != NaNporque no son necesarios el MISMO no número. Por lo tanto, tiene mucho sentido ... También por qué los flotadores tienen +0.00 y -0.00 que no son lo mismo. El redondeo puede hacer que en realidad no sean cero.

En cuanto a typeof, eso depende del idioma. Y la mayoría de los idiomas dirán que NaN es flotante, doble o número dependiendo de cómo lo clasifiquen ... No conozco ningún idioma que diga que este es un tipo desconocido o nulo.

NaNsignifica No es un número . Es un valor de tipos de datos numéricos (generalmente tipos de punto flotante, pero no siempre) que representa el resultado de una operación no válida, como dividir por cero.

Aunque sus nombres dicen que no es un número, el tipo de datos utilizado para contenerlo es un tipo numérico. Entonces, en JavaScript, NaNvolverá a solicitar el tipo de datos de number(como alert(typeof(NaN))lo demuestra claramente).

Javascript usa NaN para representar cualquier cosa que encuentre que no pueda ser representada de otra manera por sus especificaciones. No significa que no sea un número. Es la forma más fácil de describir el encuentro. NaN significa que él o un objeto que se refiere a él no podría ser representado de otra manera por javascript. A todos los efectos prácticos, es "desconocido". Siendo 'desconocido' no puede decirte qué es ni siquiera si es en sí mismo. Ni siquiera es el objeto al que está asignado. Solo puede decirte lo que no es, y la nada o la nada solo pueden describirse matemáticamente en un lenguaje de programación. Como las matemáticas son números, JavaScript representa la nada como NaN. Eso no significa que no sea un número. Significa que no podemos leerlo de otra manera que tenga sentido. Por eso puede ' t incluso igual a sí mismo. Porque no lo hace.

Un mejor nombre para NaN, describiendo su significado de manera más precisa y menos confusa, sería una excepción numérica . Realmente es otro tipo de objeto de excepción disfrazado de tipo primitivo (por el diseño del lenguaje), donde al mismo tiempo no se trata como primitivo en su falsa auto-comparación. De ahí la confusión. Y mientras el lenguaje "no decida" elegir entre un objeto de excepción apropiado y un número primitivo , la confusión se mantendrá.

La infame no igualdad de NaNsí mismo, ambos ==y ===es una manifestación del diseño confuso que obliga a este objeto de excepción a ser un tipo primitivo. Esto rompe el principio fundamental de que una primitiva está determinada únicamente por su valor . Si NaNse prefiere ser visto como una excepción (de los cuales puede haber diferentes tipos), entonces no debe "venderse" como primitivo. Y si se quiere ser primitivo, ese principio debe mantenerse. Mientras esté roto, como lo hemos hecho en JavaScript, y realmente no podemos decidir entre los dos, la confusión que conduce a una carga cognitiva innecesaria para todos los involucrados seguirá siendo. Lo cual, sin embargo, es realmente fácil de solucionar simplemente haciendo la elección entre los dos:

• haga NaNun objeto de excepción especial que contenga la información útil sobre cómo surgió la excepción, en lugar de desechar esa información como lo que está implementado actualmente, lo que lleva a un código más difícil de depurar;
• o hacer NaNuna entidad del tipo primitivo number(que podría llamarse menos confusamente "numérico"), en cuyo caso debería ser igual a sí mismo y no puede contener ninguna otra información; esta última es claramente una elección inferior.

La ventaja sólo es concebible de forzar NaNal numbertipo es ser capaz de tirar de nuevo en cualquier expresión numérica. Lo que, sin embargo, lo convierte en una opción frágil, porque el resultado de cualquier expresión numérica que contenga NaNserá NaN, o dará lugar a resultados impredecibles, como NaN < 0evaluar a false, es decir, regresar en booleanlugar de mantener la excepción.

E incluso si "las cosas son como son", nada nos impide hacer esa distinción clara para nosotros mismos, para ayudar a que nuestro código sea más predecible y más fácil de depurar. En la práctica, eso significa identificar esas excepciones y tratarlas como excepciones. Lo cual, desafortunadamente, significa más código, pero con suerte será mitigado por herramientas como TypeScript de Flowtype.

Y luego tenemos la distinción de señalizaciónNaN desordenada silenciosa vs ruidosa . Lo que realmente se trata de cómo se manejan las excepciones, no las excepciones en sí mismas, y nada diferente de otras excepciones.

Del mismo modo, Infinityy +Infinityson elementos de tipo numérico que surgen en la extensión de la línea real pero no son números reales. Matemáticamente, se pueden representar mediante secuencias de números reales que convergen a cualquiera +o -Infinity.

Esto es simplemente porque NaNes una propiedad del objeto Number en JS, no tiene nada que ver con que sea un número.

La mejor manera de pensar en NAN es que no es un número conocido . Es por eso que NAN! = NAN porque cada valor NAN representa un número único desconocido. Las NAN son necesarias porque los números de coma flotante tienen un rango limitado de valores. En algunos casos, el redondeo se produce cuando se pierden los bits más bajos, lo que conduce a lo que parece ser una tontería como 1.0 / 11 * 11! = 1.0. Los valores realmente grandes que son mayores son NAN con infinito como un ejemplo perfecto.

Dado que solo tenemos diez dedos, cualquier intento de mostrar valores mayores que 10 es imposible, lo que significa que tales valores deben ser NAN porque hemos perdido el verdadero valor de este valor mayor que 10. Lo mismo se aplica a los valores de coma flotante, donde el valor excede los límites de lo que puede mantenerse en un flotador.

Porque NaN es un tipo de datos numéricos.

NaNes un número desde un punto de vista de tipo, pero no es un número normal como 1, 2 o 329131. El nombre "No es un número" se refiere al hecho de que el valor representado es especial y se trata del dominio de especificaciones de formato IEEE, no dominio de lenguaje javascript.

Si usa jQuery, prefiero isNumericverificar el tipo:

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

http://api.jquery.com/jQuery.isNumeric/

Javascript tiene solo un tipo de datos numéricos, que es el flotante estándar de doble precisión de 64 bits. Todo es un doble. NaN es un valor especial de doble, pero no obstante es doble.

Todo lo que parseInthace es "convertir" su cadena en un tipo de datos numéricos, por lo que el resultado es siempre "número"; solo si la cadena original no se podía analizar, su valor será NaN.

NaN sigue siendo un tipo numérico, pero representa un valor que no podría representar un número válido.

Podríamos argumentar que NaN es un objeto de caso especial. En este caso, el objeto de NaN representa un número que no tiene sentido matemático. Hay otros objetos de casos especiales en matemáticas como INFINITE, etc.

Todavía puede hacer algunos cálculos con él, pero eso generará comportamientos extraños.

Más información aquí: http://www.concentric.net/~ttwang/tech/javafloat.htm (basado en java, no javascript)

Tienes que amar Javascript. Tiene algunas pequeñas peculiaridades interesantes.

http://wtfjs.com/page/13

La mayoría de esas peculiaridades se pueden explicar si se detiene para resolverlas de manera lógica, o si sabe un poco sobre teoría de números, pero aún así pueden atraparlo si no las conoce.

Por cierto, recomiendo leer el resto de http://wtfjs.com/ - ¡hay muchas peculiaridades más interesantes que esta!

El valor NaN es realmente el Número. Por lo tanto, cuando pregunte si es un número, dirá que sí. Hizo lo correcto al usar la llamada isNaN ().

Para información, NaN también puede ser devuelto por operaciones en Números que no están definidos como divisiones por cero o raíz cuadrada de un número negativo.

Un ejemplo

Imagina que estamos convirtiendo una cadena en un número:

Number("string"); // returns NaN

¡Cambiamos el tipo de datos a número pero su valor no es un número!

Es un valor especial de tipo de número como POSITIVE_INFINITY

¿Por qué? Por diseño