JavaScript -nummers
JavaScript heeft maar één type nummer. Getallen kunnen met of zonder decimalen worden geschreven.
Voorbeeld
let x = 3.14; // A number with decimals
let y = 3; // A number without decimals
Extra grote of extra kleine getallen kunnen worden geschreven met wetenschappelijke (exponente) notatie:
Voorbeeld
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
JavaScript-nummers zijn altijd 64-bits drijvende komma
In tegenstelling tot veel andere programmeertalen definieert JavaScript geen verschillende soorten getallen, zoals gehele getallen, kort, lang, drijvende komma enz.
JavaScript-nummers worden altijd opgeslagen als drijvende-kommagetallen met dubbele precisie, volgens de internationale IEEE 754-standaard.
Dit formaat slaat getallen op in 64 bits, waarbij het getal (de breuk) wordt opgeslagen in bits 0 tot 51, de exponent in bits 52 tot 62 en het teken in bit 63:
| Waarde (ook bekend als breuk / mantisse) | Exponent | Teken |
|---|---|---|
| 52 bits (0 - 51) | 11 bits (52 - 62) | 1 bit (63) |
Gehele precisie
Integers (getallen zonder punt- of exponentnotatie) zijn nauwkeurig tot 15 cijfers.
Voorbeeld
let x = 999999999999999; // x will be 999999999999999
let y = 9999999999999999; // y will be 10000000000000000
Het maximale aantal decimalen is 17.
Drijvende precisie
Floating-kommaberekeningen zijn niet altijd 100% nauwkeurig:
let x = 0.2 + 0.1;
Om het bovenstaande probleem op te lossen, helpt het om te vermenigvuldigen en te delen:
let x = (0.2 * 10 + 0.1 * 10) / 10;
Cijfers en tekenreeksen toevoegen
WAARSCHUWING !!
JavaScript gebruikt de operator + voor zowel optellen als aaneenschakelen.
Nummers worden toegevoegd. Strings zijn aaneengeschakeld.
Als u twee getallen toevoegt, is het resultaat een getal:
Voorbeeld
let x = 10;
let y = 20;
let z = x + y;
Als u twee tekenreeksen toevoegt, is het resultaat een tekenreeksaaneenschakeling:
Voorbeeld
let x = "10";
let y = "20";
let z = x + y;
Als u een getal en een tekenreeks toevoegt, is het resultaat een tekenreeksaaneenschakeling:
Voorbeeld
let x = 10;
let y = "20";
let z = x + y;
Als u een tekenreeks en een getal toevoegt, is het resultaat een tekenreeksaaneenschakeling:
Voorbeeld
let x = "10";
let y = 20;
let z = x + y;
Een veelgemaakte fout is om te verwachten dat dit resultaat 30 is:
Voorbeeld
let x = 10;
let y = 20;
let z = "The result is: " + x + y;
Een veelgemaakte fout is om te verwachten dat dit resultaat 102030 is:
Voorbeeld
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
De JavaScript-interpreter werkt van links naar rechts.
De eerste 10 + 20 wordt toegevoegd omdat x en y beide getallen zijn.
Dan wordt 30 + "30" aaneengeschakeld omdat z een string is.
Numerieke tekenreeksen
JavaScript-tekenreeksen kunnen numerieke inhoud hebben:
let x = 100; // x is a number
let y = "100"; // y is a
string
JavaScript zal bij alle numerieke bewerkingen proberen tekenreeksen naar getallen te converteren:
Dit zal werken:
let x = "100";
let y = "10";
let z = x / y;
Dit zal ook werken:
let x = "100";
let y = "10";
let z = x * y;
En dit zal werken:
let x = "100";
let y = "10";
let z = x - y;
Maar dit gaat niet werken:
let x = "100";
let y = "10";
let z = x + y;
In het laatste voorbeeld gebruikt JavaScript de + operator om de strings samen te voegen.
NaN - Geen nummer
NaN is een gereserveerd JavaScript-woord dat aangeeft dat een nummer geen wettelijk nummer is.
Als u probeert te rekenen met een niet-numerieke tekenreeks, resulteert dit in NaN(geen getal):
Voorbeeld
let x = 100 / "Apple";
Als de tekenreeks echter een numerieke waarde bevat, is het resultaat een getal:
Voorbeeld
let x = 100 / "10";
U kunt de algemene JavaScript-functie isNaN()
gebruiken om erachter te komen of een waarde een niet-getal is:
Voorbeeld
let x = 100 / "Apple";
isNaN(x);
Pas op voor NaN. Als u NaNin een wiskundige bewerking gebruikt, is het resultaat ook NaN:
Voorbeeld
let x = NaN;
let y = 5;
let z = x + y;
Of het resultaat kan een aaneenschakeling zijn zoals NaN5:
Voorbeeld
let x = NaN;
let y = "5";
let z = x + y;
NaNis een getal: typeof NaNgeeft als resultaat number:
Voorbeeld
typeof NaN;
oneindigheid
Infinity(of -Infinity) is de waarde die JavaScript retourneert als u een getal berekent dat buiten het grootst mogelijke getal ligt.
Voorbeeld
let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
}
Delen door 0 (nul) genereert ook Infinity:
Voorbeeld
let x = 2 / 0;
let y = -2 / 0;
Infinityis een getal: typeof Infinityretourneert number.
Voorbeeld
typeof Infinity;
Hexadecimaal
JavaScript interpreteert numerieke constanten als hexadecimaal als ze worden voorafgegaan door 0x.
Voorbeeld
let x = 0xFF;
Schrijf nooit een getal met een voorloopnul (zoals 07).
Sommige JavaScript-versies interpreteren getallen als octaal als ze met een voorloopnul worden geschreven.
Standaard geeft JavaScript getallen weer als decimalen met grondtal 10 .
Maar u kunt de toString()methode gebruiken om getallen van grondtal 2
naar grondtal 36 uit te voeren .
Hexadecimaal is grondtal 16 . Decimaal is grondtal 10 . Octaal is grondtal 8 . Binair is grondtal 2 .
Voorbeeld
let myNumber = 32;
myNumber.toString(10);
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(8);
myNumber.toString(2);
JavaScript-nummers als objecten
Normaal gesproken zijn JavaScript-nummers primitieve waarden die zijn gemaakt op basis van letterlijke waarden:
let x = 123;
Maar getallen kunnen ook als objecten worden gedefinieerd met het trefwoord new:
let y = new Number(123);
Voorbeeld
let x = 123;
let y = new Number(123);
Maak geen Number-objecten.
Het newsleutelwoord compliceert de code en vertraagt de uitvoeringssnelheid.
Number Objects kan onverwachte resultaten opleveren:
Bij gebruik van de ==operator zijn x en y gelijk :
let x = 500;
let y = new Number(500);
Bij gebruik van de ===operator zijn x en y niet gelijk .
let x = 500;
let y = new Number(500);
Let op het verschil tussen (x==y)en (x===y).
(x == y)waar of niet waar?
let x = new Number(500);
let y = new Number(500);
(x === y)waar of niet waar?
let x = new Number(500);
let y = new Number(500);
Comparing two JavaScript objects always returns false.
Complete JavaScript Number Reference
For a complete Number reference, visit our:
Complete JavaScript Number Reference.
The reference contains descriptions and examples of all Number properties and methods.