JavaScript
Costanti incorporate

Operazioni che restituiscono NaN

Le operazioni matematiche su valori diversi dai numeri restituiscono NaN.

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

Un'eccezione: matrici a numero singolo.

[2] * [3]  // Returns 6

Inoltre, ricorda che l'operatore + concatena le stringhe.

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

Dividere zero per zero restituisce NaN .

0 / 0         // NaN

Nota: in generale in matematica (a differenza della programmazione JavaScript), la divisione per zero non è possibile.

Funzioni della libreria matematica che restituiscono NaN

Generalmente, le funzioni Math cui vengono assegnati argomenti non numerici restituiranno NaN.

Math.floor("a")

La radice quadrata di un numero negativo restituisce NaN, poiché Math.sqrt non supporta numeri immaginari o complessi .

Math.sqrt(-1)

Test per NaN utilizzando isNaN ()

window.isNaN()

La funzione globale isNaN() può essere utilizzata per verificare se un determinato valore o espressione viene valutata in NaN . Questa funzione (in breve) verifica innanzitutto se il valore è un numero, se non tenta di convertirlo (*), quindi controlla se il valore risultante è NaN . Per questo motivo, questo metodo di prova può causare confusione .

^{(*) Il metodo di "conversione" non è così semplice, vedi ECMA-262 18.2.3 per una spiegazione dettagliata dell'algoritmo.}

Questi esempi ti aiuteranno a capire meglio il comportamento di 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

Quest'ultimo è un po 'complicato: verificare se una Array è NaN . Per fare ciò, la funzione di costruzione Number() converte prima l'array in una stringa, quindi in un numero; questo è il motivo per cui isNaN([]) e isNaN([34]) restituiscono entrambi false , ma isNaN([1, 2]) e isNaN([true]) entrambi restituiscono true : perché vengono convertiti in "" , "34" , "1,2" e "true" rispettivamente. In generale, un array è considerato NaN per isNaN() meno che non contenga un solo elemento la cui rappresentazione di stringa possa essere convertita in un numero valido .

// 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

nullo

null viene utilizzato per rappresentare l'assenza intenzionale di un valore oggetto ed è un valore primitivo. A differenza di undefined , non è una proprietà dell'oggetto globale.

È uguale a undefined ma non identico ad esso.

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

ATTENZIONE : il typeof null è 'object' .

typeof null; // 'object';

Per verificare correttamente se un valore è null , confrontarlo con l' operatore di uguaglianza rigorosa

var a = null;

a === null; // true

non definito e nullo

A prima vista può sembrare che null e undefined siano fondamentalmente uguali, tuttavia ci sono differenze sottili ma importanti.

undefined è l'assenza di un valore nel compilatore, perché dove dovrebbe essere un valore, non è stato messo uno, come nel caso di una variabile non assegnata.

• undefined è un valore globale che rappresenta l'assenza di un valore assegnato.
  • typeof undefined === 'undefined'
• null è un oggetto che indica che una variabile è stata assegnata in modo esplicito "nessun valore".
  • typeof null === 'object'

Impostare una variabile su undefined significa che la variabile effettivamente non esiste. Alcuni processi, come la serializzazione JSON, possono undefined proprietà undefined dagli oggetti. Al contrario, le proprietà null indicano che saranno conservate in modo da poter esplicitamente trasmettere il concetto di una proprietà "vuota".

Le seguenti valutazioni undefined :

• Una variabile quando viene dichiarata ma non assegnata ad un valore (cioè definito)

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

• Accedere al valore di una proprietà che non esiste

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

• Il valore di ritorno di una funzione che non restituisce un valore

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

• Il valore di un argomento di funzione dichiarato ma che è stato omesso dalla chiamata di funzione

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

undefined è anche una proprietà dell'oggetto window globale.

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

Infinito e -Infinito

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

Infinity è una proprietà dell'oggetto globale (quindi una variabile globale) che rappresenta l'infinito matematico. È un riferimento a Number.POSITIVE_INFINITY

È maggiore di qualsiasi altro valore e puoi ottenerlo dividendo per 0 o valutando l'espressione di un numero così grande che trabocca. Questo in realtà significa che non c'è divisione per 0 errori in JavaScript, c'è Infinity!

C'è anche -Infinity che è infinito negativo matematico ed è inferiore a qualsiasi altro valore.

Per ottenere -Infinity si annulla Infinity o si ottiene un riferimento ad esso in Number.NEGATIVE_INFINITY .

- (Infinity); // -Infinity

Ora divertiamoci con gli esempi:

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 sta per "Not a Number". Quando una funzione matematica o un'operazione in JavaScript non può restituire un numero specifico, restituisce invece il valore NaN .

È una proprietà dell'oggetto globale e un riferimento a Number.NaN

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

Forse confondendo, NaN è ancora considerato un numero.

typeof NaN; // 'number'

Non cercare NaN usando l'operatore di uguaglianza. Vedi invece isNaN .

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

Numero costante

Il costruttore di Number ha alcune costanti incorporate che possono essere utili

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

In molti casi i vari operatori in Javascript si romperanno con valori non compresi nell'intervallo ( Number.MIN_SAFE_INTEGER , Number.MAX_SAFE_INTEGER )

Notare che Number.EPSILON rappresenta il diverso tra uno e il Number più piccolo maggiore di uno e quindi la differenza più piccola possibile tra due diversi valori Number . Uno dei motivi per cui questo è dovuto alla natura di come i numeri vengono memorizzati da JavaScript vedi Controlla l'uguaglianza di due numeri