Perché typeof NaN restituisce "numero"?

https://stackoverflow.com/questions/2801601

25-09-2019
|

Domanda

Solo per curiosità.

Non sembra molto logico typeof NaN è il numero.Proprio come NaN === NaN O NaN == NaN restituendo false, comunque.È questa una delle peculiarità di Javascript o ci sarebbe un motivo?

Modificare:grazie per le tue risposteTuttavia non è una cosa facile convincere la gente.Leggendo le risposte e il wiki ho capito di più, ma comunque, una frase simile

Un confronto con un NaN restituisce sempre un risultato non ordinato anche quando si confronta con se stesso.I predicati di confronto sono di segnalazione o non di segnalazione, le versioni di segnalazione segnalano un'eccezione non valida per tali confronti.I predicati di uguaglianza e disuguaglianza non sono di segnalazione, quindi x = x che restituisce false può essere utilizzato per verificare se x è un NaN tranquillo.

mi fa girare la testa.Se qualcuno potesse tradurlo in un linguaggio leggibile dall'uomo (al contrario, ad esempio, dal matematico), ne sarei grato.

Soluzione

Ciò significa Not a Number. Non è una peculiarità di javascript, ma comune principio di informatica.

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

Ci sono tre tipi di funzionamento   che restituiscono NaN:

Operazioni con NaN come almeno un operando

forme indeterminate


Le divisioni 0/0, ∞ / ∞, ∞ / -∞, -∞ / ∞, e -∞ / -∞

Le moltiplicazioni 0 × ∞ e 0 × -∞

Il potere 1 ^ ∞

Le aggiunte ∞ + (-∞), (-∞) + ∞ e sottrazioni equivalenti.


operazioni reali con risultati complessi:


La radice quadrata di un numero negativo

Il logaritmo di un numero negativo

La tangente di un multiplo dispari di 90 gradi (o n / 2 radianti)

Il seno inverso o coseno di un numero che è inferiore a -1 o   maggiore di +1.

Tutti questi valori non può essere lo stesso. Un test semplice per un NaN è quello di testare value == value è falso.

Altri suggerimenti

Bene, NaN è ancora un numerica tipo , nonostante il fatto che in realtà sta per Non-A-Numero: -)

NaN significa solo del valore specifico non può essere rappresentato nei limiti del tipo numerico (anche se si potrebbe dire per tutti i numeri che devono essere opportunamente arrotondato, ma NaN è un caso speciale).

A NaN specifico non è considerato uguale a un altro NaN perché possono essere valori diversi. Tuttavia, NaN è ancora un tipo di numero, proprio come 2718 o 31415.

Per quanto riguarda la tua domanda aggiornato per spiegare in parole povere:

Un confronto con un NaN restituisce sempre un risultato non ordinata, anche quando si confrontano con se stesso. I predicati di confronto sono o di segnalazione o di non segnalazione, le versioni di segnalazione segnalano un'eccezione non valido per tali confronti. I predicati di uguaglianza e disuguaglianza sono non segnalando così x = x ritorno falso può essere utilizzato per testare se x è un tranquillo NaN.

Tutto questo significa (suddiviso in parti):

Un confronto con un NaN restituisce sempre un risultato non ordinata, anche quando si confrontano con se stesso.

In sostanza, un NaN non è uguale a qualsiasi altro numero, compreso un altro NaN, e anche compreso si .

I predicati di confronto sono o segnalando o non segnalazione, le versioni di segnalazione segnale un'eccezione non valido per tali confronti.

Il tentativo di fare il confronto (meno di, maggiore di, e così via) operazioni tra un NaN e un altro numero può sia causare un'eccezione essere gettato (segnalazione) o semplicemente ottenere falso come il risultato (non di segnalazione o silenziosa) .

I predicati di uguaglianza e disuguaglianza sono non segnalando così x = x ritorno falso può essere utilizzato per testare se x è un tranquillo NaN.

Verifica l'uguaglianza (pari, non uguale a) non sono mai segnalando quindi il loro utilizzo non causerà un'eccezione. Se si dispone di un numero normale x, quindi x == x sarà sempre vero. Se x è un NaN, allora x == x sarà sempre falso. E si sta dando un modo per rilevare NaN facilmente (a bassa voce).

L'ECMAScript (JavaScript) specifica standard che Numbers sono IEEE 754 galleggianti, che includono NaN come un possibile valore.

ECMA 262 5e Sezione 4.3.19 : Numero valore

valore primitivo corrispondente ad una doppia precisione a 64-bit formato binario IEEE valore 754.

ECMA 262 Sezione 4.3.23 5e : NaN

valore numerico che è un IEEE 754 "Not-a-Number" value.

IEEE 754 su Wikipedia

L'IEEE Standard per aritmetica alla virgola mobile è uno standard tecnico elaborato dall'Institute of Electrical and Electronics Engineers e lo standard più utilizzato per floating-point calcolo [...]

L'definisce standard


formati aritmetiche : insiemi di dati binari e decimali in virgola mobile, che consistono di numeri finiti (includendo degli zeri firmati e numeri subnormali), infiniti e valori speciale "non un numero" (NaNs)


[...]

ritorna typeof NaN 'number' perché:

ECMAScript specifiche dice il tipo di numero comprende NaN:


4.3.20 tipo Number

insieme di tutti i possibili valori numerici tra cui lo speciale “Not-a-Number”   valori (NaN), infinito positivo e negativo infinito

Quindi typeof rendimenti di conseguenza:

11.4.3 Il typeof Operatore

La produzione UnaryExpression : typeof UnaryExpression è valutato come segue:

Let val essere il risultato della valutazione di UnaryExpression .
Tipo ( val ) è < a href = "http://www.ecma-international.org/ecma-262/5.1/#sec-8.7"> Riferimenti , poi
1. IsUnresolvableReference ( val ) è < strong> true , il ritorno "undefined".
2. Lasciate che val GetValue ( val ).
restituire una stringa determinati da tipo ( val ) secondo la tabella 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".            |
------------------------------------------------------------------

Questo comportamento è in accordo con IEEE Standard per aritmetica alla virgola mobile (IEEE 754) :

4.3.19 valore Numero

valore primitivo corrispondente ad una doppia precisione a 64-bit binario   formato IEEE 754 valore

4.3.23 NaN

valore numerico che è un IEEE 754 “Not-a-Number” Valore

8.5 il tipo di numero

Il tipo Number ha esattamente 18437736874454810627 (cioè, 2 ⁵³ -2 ⁶⁴ 3)   valori che rappresentano la doppia precisione a 64 bit formato IEEE 754   valori come specificato nella IEEE Standard per Binary virgola mobile   Aritmetica, salvo che il 9007199254740990 (cioè, 2 ⁵³ -2) distinta   valori “Not-a-Number” della IEEE standard sono rappresentati in   ECMAScript come un unico speciale NaN di valore. (Si noti che il NaN Valore   è prodotto dalla NaN espressione programma).

NaN è un valore in virgola mobile valido ( http://en.wikipedia.org/wiki/NaN )

e NaN === NaN è falso perché non sono necessariamente la stessa non-numero

NaN != NaN perché non sono necessari il numero di non-STESSO. Così si fa un sacco di senso ... Anche perché i galleggianti hanno sia +0,00 e -0,00 che non sono la stessa cosa. Arrotondamento può fanno che essi sono in realtà non è zero.

Come per typeof, che dipende dalla lingua. E la maggior parte lingue diranno che Nan è un float, double o numero a seconda di come si classificano ... Non conosco nessun lingue che dicono che questo è un tipo sconosciuto o nullo.

NaN sta per href="http://en.wikipedia.org/wiki/NaN" rel="nofollow"> Not a Number . Si tratta di un valore dei tipi di dati numerici (tipi di punti normalmente flottante, ma non sempre) che rappresenta il risultato di un'operazione non valida come la divisione per zero.

Anche se il suo nome dice che non è un numero, il tipo di dati utilizzato per contenere si tratta di un tipo numerico. Così in JavaScript, chiedendo per il tipo di dati NaN tornerà number (come alert(typeof(NaN)) dimostra chiaramente).

Javascript utilizza NaN per rappresentare tutto ciò che incontra, che non può essere rappresentato da qualsiasi altro modo le sue specifiche. Ciò non significa che non è un numero. E 'solo il modo più semplice per descrivere l'incontro. NaN significa che o un oggetto che si riferisce ad esso non può essere rappresentato in altro modo da JavaScript. Per tutti gli scopi pratici, è 'sconosciuto'. Essere 'sconosciuto', non si può dire di cosa si tratta e nemmeno se è in sé. Non è nemmeno l'oggetto a cui è assegnato. E si può dire solo ciò che non è, e non-ness o nulla può solo essere descritto matematicamente in un linguaggio di programmazione. Dal momento che la matematica è di numeri, javascript rappresenta il nulla come NaN. Questo non vuol dire che non è un numero. Significa che non possiamo leggere in altro modo che abbia senso. Ecco perché non può nemmeno sé eguagliare. Perché non è così.

Un nome migliore per NaN, descrivendo il suo significato più preciso e meno confusamente, sarebbe un eccezione numerico . E 'davvero un altro tipo di oggetto eccezione travestito da avere tipo primitivo (dalla progettazione del linguaggio), dove allo stesso non è trattato come primitivo nella sua falsa auto-confronto. Da qui la confusione. E finché la lingua "non farà la sua mente" di scegliere tra corretta oggetto eccezione e primitiva numerale , la confusione rimane.

L'infame non parità di NaN a se stessa, sia == e === è una manifestazione del disegno confondere forzandolo oggetto eccezione in essere un tipo primitivo. Questo rompe il principio fondamentale che un primitivo è determinato unicamente dal suo valore . Se NaN è preferito ad essere visto come eccezione (di cui ci possono essere diversi tipi), allora non dovrebbe essere "venduto" come primitivi. E se si vuole essere primitivo, tale principio deve essere in possesso. Fino a quando si è rotto, come abbiamo fatto in JavaScript, e non può davvero decidere tra i due, la confusione che porta a carico cognitivo inutile per tutti i soggetti coinvolti rimarranno. Il che, tuttavia, è davvero facile da risolvere semplicemente facendo la scelta tra i due:

o make NaN un oggetto eccezione speciale contenente le informazioni utili su come l'eccezione sorto, al contrario di gettare le informazioni via come ciò che è attualmente implementato, che porta a codice più difficile da eseguire il debug;
o make NaN un'entità di tipo primitivo number (che potrebbe essere meno confusamente chiamato "numerico"), nel qual caso deve essere uguale a se stesso e non possono contenere tutte le altre informazioni; quest'ultimo è chiaramente una scelta inferiore.

Il vantaggio unico concepibile di forzare NaN in tipo number è riuscire a passi indietro in nessuna espressione numerica. Che, tuttavia, rende fragile scelta, perché il risultato di un'espressione numerica contenente NaN o sarà NaN, o portano a risultati imprevedibili come NaN < 0 valutare a false, cioè ritornando boolean invece di mantenere l'eccezione.

E anche se "le cose sono come sono", nulla ci impedisce di fare questa distinzione chiara per noi stessi, per contribuire a rendere il nostro codice più prevedibile e easierly debuggable. In pratica, ciò significa identificare tali eccezioni e trattare con loro come eccezioni. Il che, purtroppo, è il codice di più, ma si spera sarà mitigata da strumenti quali dattiloscritto di Flowtype.

E poi abbiamo il disordinato tranquilla vs rumoroso alias segnalazione NaN distinzione . Che è davvero su come eccezioni vengono gestite, non le eccezioni stessi, e nulla di diverso da altre eccezioni.

Similmente, Infinity e +Infinity sono elementi di tipo numerico derivante nell'estensione di il vero linea ma non sono numeri reali. Matematicamente, possono essere rappresentati da sequenze di numeri reali convergenti a uno o + -Infinity.

Questo è semplicemente perché NaN è una proprietà dell'oggetto Number in JS, non ha nulla a che fare con esso che è un numero.

Il modo migliore per pensare a NAN è che non è un conosciuto numero.Ecco perché NAN!= NAN perché ogni valore NAN rappresenta un numero univoco sconosciuto.Le NAN sono necessarie perché i numeri in virgola mobile hanno un intervallo di valori limitato.In alcuni casi si verifica l'arrotondamento in cui i bit inferiori vengono persi, il che porta a ciò che sembra essere senza senso come 1.0/11*11 != 1.0.Valori davvero grandi che sono maggiori sono i NAN con infinito che è un esempio perfetto.

Dato che abbiamo solo dieci dita, qualsiasi tentativo di mostrare valori superiori a 10 è impossibile, il che significa che tali valori devono essere NAN perché abbiamo perso il vero valore di questo valore maggiore di 10.Lo stesso vale per i valori in virgola mobile, dove il valore supera i limiti di ciò che può essere contenuto in un float.

Poiché NaN è un tipo di dati numerico.

NaN è un numero da un punto di vista tipo, ma non è un numero normale come 1, 2 o 329131. Il nome "non un numero" si riferisce al fatto che il valore rappresentato è speciale ed è circa il dominio del formato IEEE spec, non javascript dominio della lingua.

Se si utilizza jQuery, preferisco isNumeric sopra il controllo del tipo:

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

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

JavaScript ha un solo tipo di dati numerici, che è il galleggiante doppia precisione standard a 64-bit. Tutto è un doppio. Nan è un valore speciale di doppio, ma si tratta di una doppia comunque.

Tutto ciò che fa è parseInt a "cast" la stringa in un tipo di dati numerici, quindi il risultato è sempre "numero"; solo se la stringa originale non era da interpretare, il suo valore sarà NaN.

NaN è ancora un tipo numerico, ma rappresenta un valore che non poteva rappresentare un numero valido.

Si potrebbe sostenere che Nan è un oggetto speciale caso. In questo caso, oggetto di NaN rappresenta un numero che non ha senso matematico. Ci sono alcuni altri oggetti speciali di casi in matematica come infinito e così via.

Si può ancora fare alcuni calcoli con esso, ma che produrrà i comportamenti strani.

Più informazioni su: http://www.concentric.net/~ttwang/ Tech / javafloat.htm (basato su Java, non javascript)

Hai avuto modo di amare Javascript. Ha alcune interessanti piccole manie.

http://wtfjs.com/page/13

La maggior parte di quei capricci può essere spiegata se si smette di lavorare fuori logicamente, o se si conosce un po 'di teoria dei numeri, ma tuttavia possono ancora prendere se non si sa su di loro.

A proposito, vi consiglio di leggere il resto di http://wtfjs.com/ - c'è un sacco peculiarità più interessante di questo per essere trovato!

Il valore NaN è davvero il Number.NaN quindi quando si chiede se si tratta di un numero che dirà sì. Hai fatto la cosa giusta utilizzando la chiamata isNaN ().

Per informazioni, NaN può essere restituito da operazioni su numeri che non sono definiti come divisioni per zero o radice quadrata di un numero negativo.

Un esempio

Immaginate Stiamo convertendo una stringa in un numero:

Number("string"); // returns NaN

Abbiamo cambiato il tipo di dati per il numero ma il suo valore non è un numero!

Si tratta di un valore speciale di tipo Number come POSITIVE_INFINITY

Perché? In base alla progettazione

Autorizzato sotto: CC-BY-SA insieme a attribuzione

Non affiliato a StackOverflow