JavaScript
Ingebouwde constanten

Bewerkingen die NaN retourneren

Wiskundige bewerkingen op andere waarden dan getallen retourneren NaN.

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

Een uitzondering: arrays met één nummer.

[2] * [3]  // Returns 6

Onthoud ook dat de operator + tekenreeksen samenvoegt.

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

Het delen van nul door nul levert NaN .

0 / 0         // NaN

Opmerking: in de wiskunde in het algemeen (in tegenstelling tot bij JavaScript-programmering) is delen door nul niet mogelijk.

Wiskundige bibliotheekfuncties die NaN retourneren

Over het algemeen geven Math functies die niet-numerieke argumenten krijgen NaN terug.

Math.floor("a")

De vierkantswortel van een negatief getal retourneert NaN, omdat Math.sqrt geen denkbeeldige of complexe getallen ondersteunt.

Math.sqrt(-1)

Testen op NaN met isNaN ()

window.isNaN()

De globale functie isNaN() kan worden gebruikt om te controleren of een bepaalde waarde of uitdrukking isNaN() in NaN . Deze functie controleert (kort gezegd) eerst of de waarde een getal is, zo niet, probeert deze te converteren (*), en controleert vervolgens of de resulterende waarde NaN . Om deze reden kan deze testmethode verwarring veroorzaken .

^{(*) De "conversie" -methode is niet zo eenvoudig, zie ECMA-262 18.2.3 voor een gedetailleerde uitleg van het algoritme.}

Deze voorbeelden helpen u het gedrag van isNaN() beter te begrijpen:

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

Deze laatste is een beetje lastig: controleren of een Array NaN . Om dit te doen, converteert de constructor Number() eerst de array naar een string en vervolgens naar een getal; dit is de reden waarom isNaN([]) en isNaN([34]) beide false retourneren, maar isNaN([1, 2]) en isNaN([true]) beide true teruggeven: omdat ze worden omgezet in "" , "34" , "1,2" en "true" respectievelijk. Over het algemeen wordt een array beschouwd als NaN door isNaN() tenzij deze slechts één element bevat waarvan de isNaN() kan worden geconverteerd naar een geldig getal .

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

nul

null wordt gebruikt voor de opzettelijke afwezigheid van een objectwaarde en is een primitieve waarde. In tegenstelling tot undefined is het geen eigenschap van het globale object.

Het is gelijk aan undefined maar niet identiek eraan.

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

LET OP: De typeof null is 'object' .

typeof null; // 'object';

Vergelijk goed met de operator voor strikte gelijkheid om te controleren of een waarde null is

var a = null;

a === null; // true

ongedefinieerd en nul

Op het eerste gezicht lijkt het erop dat null en undefined in principe hetzelfde zijn, maar er zijn subtiele maar belangrijke verschillen.

undefined is de afwezigheid van een waarde in de compiler, omdat waar het een waarde zou moeten zijn, er geen is gezet, zoals het geval van een niet-toegewezen variabele.

• undefined is een globale waarde die de afwezigheid van een toegewezen waarde vertegenwoordigt.
  • typeof undefined === 'undefined'
• null is een object dat aangeeft dat aan een variabele expliciet "geen waarde" is toegewezen.
  • typeof null === 'object'

Een variabele instellen op undefined betekent dat de variabele feitelijk niet bestaat. Sommige processen, zoals JSON-serialisatie, kunnen undefined eigenschappen van objecten verwijderen. null eigenschappen daarentegen worden bewaard zodat u het concept van een "lege" eigenschap expliciet kunt overbrengen.

Het volgende wordt als undefined :

• Een variabele wanneer deze wordt gedeclareerd maar geen waarde wordt toegewezen (dwz gedefinieerd)

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

• Toegang krijgen tot de waarde van een eigenschap die niet bestaat

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

• De retourwaarde van een functie die geen waarde retourneert

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

• De waarde van een functieargument dat is gedeclareerd maar uit de functieaanroep is weggelaten

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

undefined is ook een eigenschap van het globale window .

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

Infinity en -Infinity

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

Infinity is een eigenschap van het globale object (dus een globale variabele) die wiskundige oneindigheid vertegenwoordigt. Het is een verwijzing naar Number.POSITIVE_INFINITY

Het is groter dan elke andere waarde, en je kunt het krijgen door te delen door 0 of door de uitdrukking te evalueren van een getal dat zo groot is dat het overloopt. Dit betekent eigenlijk dat er geen deling door 0 fouten is in JavaScript, er is oneindigheid!

Er is ook -Infinity die wiskundig negatieve oneindigheid is, en deze is lager dan elke andere waarde.

Om Number.NEGATIVE_INFINITY te krijgen -Infinity je Infinity , of krijg je een verwijzing ernaar in Number.NEGATIVE_INFINITY .

- (Infinity); // -Infinity

Laten we nu wat plezier hebben met voorbeelden:

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 staat voor "Not a Number." Wanneer een wiskundige functie of bewerking in JavaScript geen specifiek getal kan retourneren, retourneert het in plaats daarvan de waarde NaN .

Het is een eigenschap van het globale object en een verwijzing naar Number.NaN

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

Misschien verwarrend, wordt NaN nog steeds als een getal beschouwd.

typeof NaN; // 'number'

Controleer niet op NaN met de operator voor gelijkheid. Zie isNaN plaats daarvan isNaN .

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

Aantal constanten

De constructor Number heeft een aantal ingebouwde constanten die nuttig kunnen zijn

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 veel gevallen breken de verschillende operatoren in Javascript met waarden buiten het bereik van ( Number.MIN_SAFE_INTEGER , Number.MAX_SAFE_INTEGER )

Merk op dat Number.EPSILON vertegenwoordigt het verschil tussen één en kleinste Number groter is dan één, en dus de kleinst mogelijke verschil tussen twee verschillende Number waarden. Een reden om dit te gebruiken is te wijten aan de aard van de manier waarop nummers worden opgeslagen door JavaScript. Zie De gelijkheid van twee nummers controleren