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

https://stackoverflow.com/questions/2801601

25-09-2019
|

Pregunta

Sólo por curiosidad.

No parece muy lógico que typeof NaN es número. Al igual que NaN === NaN o NaN == NaN devolver falso, por cierto. Es esta una de las peculiaridades de JavaScript, o habría una razón para esto?

Edit: Gracias por sus respuestas. No es una cosa fácil de conseguir unos cabeza alrededor sin embargo. La lectura de las respuestas y la wiki me entiende más, pero aún así, una frase como

Una comparación con un NaN siempre devuelve un resultado desordenada incluso cuando se comparan con ella misma. Los predicados de comparación son ya sea señalización o no señalización, las versiones señal de señalización de una excepción no válido para tales comparaciones. Los predicados de igualdad y desigualdad se no de señalización lo que x = x falso volver puede ser utilizado para probar si x es un tranquilo NaN.

sólo sigue mi cabeza dando vueltas. Si alguien puede traducir esto en humanos (a diferencia de, digamos, matemático) lenguaje legible, estaría agradecido.

Solución

Esto significa que no es un número. No es una peculiaridad de javascript pero principio de la informática común.

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

Hay tres tipos de operación   que devuelven NaN:

Operaciones con un NaN como al menos un operando

formas indeterminadas


Las divisiones 0/0, ∞ / ∞, ∞ / -∞, -∞ / ∞ y -∞ / -∞

Las multiplicaciones 0 × 0 × ∞ y -∞

El poder 1 ^ ∞

Las adiciones ∞ + (-∞), (-∞) + ∞ y sustracciones equivalentes.


Las operaciones propiamente dichas, 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 pi / 2 radianes)

El seno inverso o coseno de un número que es menor que -1 o   mayor que 1.

Todos estos valores no puede ser el mismo. Una prueba simple para un NaN es value == value prueba es falsa.

Otros consejos

Bueno, NaN sigue siendo un numérico type , a pesar del hecho de que en realidad es sinónimo de No-A-Number: -)

NaN sólo significa 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 tienen que ser redondeado a forma, pero NaN es un caso especial).

A NaN específica no se considera igual a otro NaN ya que pueden ser valores diferentes. Sin embargo, NaN sigue siendo un tipo de número, al igual que 2718 o 31415.

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

Una comparación con un NaN siempre devuelve un resultado desordenada incluso cuando se comparan con ella misma. Los predicados de comparación son ya sea señalización o no señalización, las versiones señal de señalización de una excepción no válido para tales comparaciones. Los predicados de igualdad y desigualdad se no de señalización lo que x = x volver falsa puede ser utilizado para probar si x es un tranquilo NaN.

Todos los medios esto es (descomponen en partes):

Una comparación con un NaN siempre devuelve un resultado desordenada incluso cuando se comparan con ella misma.

Básicamente, un NaN no es igual a cualquier otro número, incluyendo otra NaN, e incluso incluyendo sí .

Los predicados de comparación son la señalización, ya sea o no de señalización, las versiones señal de señalización de una excepción no válido para tales comparaciones.

El intento de hacer la comparación (menor que, mayor que, etc.) las operaciones entre un NaN y otro número cualquiera puede dar lugar a una excepción que es lanzado (señalización) o simplemente conseguir falso como el resultado (no señalización o tranquilo) .

Los predicados de igualdad y desigualdad no se permite la señalización de modo x = x volver falsa puede ser utilizado para probar si x es un tranquilo NaN.

Las pruebas para la igualdad (igual a, no es igual a) nunca son la señalización lo que su uso no causa una excepción. Si usted tiene un número x regular, entonces x == x siempre será cierto. Si x es un NaN, entonces x == x siempre será falsa. Se le está dando una forma de detectar NaN fácilmente (en voz baja).

El ECMAScript (JavaScript) previsto por la norma que Numbers son IEEE 754 flotadores, que incluyen NaN como un valor posible.

ECMA 262 5e Sección 4.3.19 : Número valor

valor simple que corresponde a una doble precisión de 64 bits formato binario IEEE valor 754.

ECMA 262 5e Sección 4.3.23 : NaN

valor numérico que es un IEEE 754 "Not-a-Number" valor.

IEEE 754 Wikipedia

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

Los define estándar


formatos aritméticas : conjuntos de datos binarios y decimales de coma flotante, que consisten en números finitos (incluyendo ceros firmados y números subnormales), infinitos, y los valores especial "no es un número" (NaNs)


[...]

retornos typeof NaN 'number' porque:

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


4.3.20 Tipo Número

conjunto de todos los posibles valores numéricos incluyendo el especial “Not-a-Number”   valores (NAN), infinito positivo, y el infinito negativo

Así que vuelve typeof en consecuencia:

11.4.3 El operador typeof

La producción de UnaryExpression : typeof UnaryExpression es evaluado como sigue:

Let val sea el resultado de evaluar UnaryExpression .
Tipo ( val ) es < a href = "http://www.ecma-international.org/ecma-262/5.1/#sec-8.7"> de referencia, a continuación,
1. IsUnresolvableReference ( val ) es < strong> true , el retorno "undefined".
2. Let val GetValue ( val ).
Devuelve una cadena determinada por Tipo ( 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 Norma IEEE para aritmética de punto flotante (IEEE 754) :

4.3.19 Número valor

valor simple que corresponde a una de doble precisión binario de 64 bits   formato IEEE 754 de valor

4.3.23 NaN

valor numérico que es un IEEE 754 “Not-a-Number” valor

8.5 el número de tipo

el tipo de número tiene exactamente 18437736874454810627 (es decir, 2 ⁵³ -2 ⁶⁴ 3)   valores, lo que representa el doble precisión de 64 bits formato IEEE 754   valores como se especifica en la Norma IEEE para binario de punto flotante   Aritmética, excepto que la 9007199254740990 (es decir, 2 ⁵³ -2) distinta   los valores de “No-A-Number” de la Norma IEEE están representados en   ECMAScript como una sola especial NaN valor. (Nota que el NaN valor   se produce por la NaN expresión programa.)

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

y NaN NaN === es falsa porque no son necesariamente los mismos no número

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

En cuanto a typeof, que depende del idioma. Y la mayoría de las lenguas dirán que NaN es un flotador, doble o número dependiendo de cómo se clasifican ... No conozco ningún lenguas que dicen que esto es un tipo o nula desconocido.

NaN significa href="http://en.wikipedia.org/wiki/NaN" rel="nofollow"> no es un número . Es un valor de tipos de datos numéricos (generalmente los tipos de puntos flotantes, pero no siempre) que representa el resultado de una operación no válida, tal como la división por cero.

A pesar de sus nombres, dice que no es un número, el tipo de datos se utiliza para mantener que es un tipo numérico. Así que en JavaScript, preguntando por el tipo de datos de NaN se number volver (como se demuestra claramente alert(typeof(NaN))).

Javascript utiliza NaN para representar cualquier cosa que encuentra que no se puede representar cualquier otra forma por sus especificaciones. Esto no quiere decir que no es un número. Es sólo la forma más fácil de describir el encuentro. NaN significa que o un objeto que se refiere a ella no podría representarse de cualquier otra manera por javascript. Para todos los propósitos prácticos, es 'desconocido'. Siendo 'desconocido' que no se puede decir lo que es, ni siquiera si se trata de sí mismo. Ni siquiera es el objeto al que está asignado. Sólo se le puede decir lo que no es, y no-dad o la nada sólo puede ser descrita matemáticamente en un lenguaje de programación. Dado que las matemáticas son acerca de los números, javascript representa la nada como NaN. Eso no quiere decir que no es un número. Esto significa que no podemos leerlo cualquier otra forma que tenga sentido. Es por eso que ni siquiera puede ser igual a sí mismo. Debido a que no lo hace.

Un mejor nombre para NaN, describiendo su significado más precisa y menos confusamente, sería un excepción numérica . Es realmente otro tipo de objeto de excepción disfrazado de tener tipo primitivo (por el diseño del lenguaje), donde al mismo que no se trata como primitivo en su falsa auto-comparación. De ahí la confusión. Y siempre que el lenguaje "no hará que su mente" para elegir entre los objeto de excepción adecuada y primitiva numeral , la confusión va a quedar.

El infame no igualdad de NaN a sí misma, tanto == y === es una manifestación del diseño confuso obligando a este objeto de excepción en ser un tipo primitivo. Esto rompe el principio fundamental de que un primitiva se determina de forma única por su valor . Si se prefiere NaN a ser vista como una excepción (de los cuales no puede haber diferentes tipos), entonces no debe ser "vendido" como primitivos. Y si se quiere ser primitivo, este principio debe sostener. Con tal de que se ha roto, como lo hemos hecho en JavaScript, y que en realidad no puede decidir entre los dos, la confusión que lleva a la carga cognitiva necesaria para todos los involucrados se mantendrá. Que, sin embargo, es muy fácil de solucionar simplemente hacer la elección entre los dos:

o bien hacer NaN un objeto excepción especial que contiene la información útil sobre cómo surgió la excepción, en lugar de tirar esa información a medida que lo que está actualmente en marcha, lo que lleva al código más difíciles de depurar;
o hacer NaN una entidad de la number tipo primitivo (que se podría llamar menos confusamente "numérico"), en cuyo caso debe ser igual a sí mismo y no puede contener cualquier otra información; este último es claramente una opción inferior.

La ventaja sólo es concebible de forzar NaN en tipo number es ser capaz de tirar de nuevo en cualquier expresión numérica. Lo cual, sin embargo, hace que sea elección quebradizo, ya que el resultado de cualquier expresión numérica que contiene NaN o bien será NaN o conducen a resultados impredecibles, tales como NaN < 0 evaluar a false, es decir, volver boolean en lugar de mantener la excepción.

Y aunque "las cosas son como son", nada nos impide hacer esa distinción clara para nosotros mismos, para ayudar a que nuestro código predecible y simplifique depurable más. En la práctica, eso significa que la identificación de las excepciones y tratar con ellos como excepciones. Que, por desgracia, los medios más código pero esperemos que se mitigará mediante herramientas como texto mecanografiado de Flowtype.

Y luego tenemos el desordenado tranquila vs ruidosa aka señalización distinción NaN . Que en realidad se trata de cómo se manejan excepciones, no las excepciones a sí mismos, y nada diferente de otras excepciones.

Del mismo modo, Infinity y +Infinity son elementos de tipo numérico que surge en la extensión de la recta real, pero no son los números reales. Matemáticamente, que pueden ser representados por secuencias de números reales convergentes a cualquiera + o -Infinity.

Esto es simplemente porque NaN es una propiedad del objeto Número de JS, No tiene nada que ver con que sea un número.

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

Dado que sólo tenemos diez dedos cualquier intento de mostrar valores superiores a 10 son imposibles, lo que significa que estos valores deben ser NAN porque hemos perdido el verdadero valor de este valor mayor que 10. Lo mismo es cierto de valores de coma flotante, en el que el valor excede de los límites de lo que puede ser realizado en un flotador.

Debido NaN es un tipo de datos numéricos.

NaN es 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 de dominio del formato IEEE especificaciones, no de dominio lenguaje Javascript.

Si se utiliza jQuery, prefiero isNumeric sobre la comprobación del tipo:

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

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

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

Todo lo que hace es parseInt "fundido" de su cadena en un tipo de datos numéricos, por lo que el resultado es siempre "número"; sólo si la cadena original no era analizable, su valor será NaN.

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

podría argumentar que NaN es un objeto especial caso. En este caso, objeto de NaN representa un número que no tiene sentido matemático. Hay algunos otros objetos de casos especiales en matemáticas como infinito y así sucesivamente.

Usted todavía puede hacer algunos cálculos con ella, pero que dará lugar a 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 peculiaridades poco interesante.

http://wtfjs.com/page/13

La mayor parte de esos caprichos puede explicarse si uno se pone a trabajar con ellas de forma lógica, o si usted sabe un poco acerca de la teoría de números, pero sin embargo todavía se puede tomar si usted no sabe acerca de ellos.

Por cierto, recomiendo leer el resto de http://wtfjs.com/ - hay mucho peculiaridades más interesantes que éste que se encuentran!

El valor NaN es realmente el Number.NaN por lo tanto, cuando se pregunta si se trata de un número que va a decir que sí. Usted hizo lo correcto utilizando la llamada isNaN ().

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

Un ejemplo

Imagínese Estamos convirtiendo una cadena en un número:

Number("string"); // returns NaN

Hemos cambiado el tipo de datos de número, pero su valor no es un número!

Es de una calidad especial de tipo numérico como POSITIVE_INFINITY

¿Por qué? Por diseño

Licenciado bajo: CC-BY-SA con atribución

No afiliado a StackOverflow