JavaScript heeft slechts één type nummer. Getallen kunnen met of zonder decimalen worden geschreven.
Voorbeeld
var x = 3.14; // A number with decimals
var y = 3; // A number without decimals
Extra grote of extra kleine getallen kunnen met wetenschappelijke (exponent) notatie worden geschreven:
Voorbeeld
var x = 123e5; // 12300000
var 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, korte, lange, drijvende komma enz.
JavaScript-nummers worden altijd opgeslagen als drijvende-kommagetallen met dubbele precisie.
Dit formaat slaat getallen op in 64 bits. Gehele getallen (getallen zonder punt of exponentnotatie) zijn nauwkeurig tot 15 cijfers.
Voorbeeld
var x = 999999999999999; // x will be 999999999999999
var y = 9999999999999999; // y will be 10000000000000000
Het aantal maximale decimalen is 17, maar drijvende-kommaberekeningen zijn niet altijd 100% nauwkeurig:
Voorbeeld
var x = 0.2 + 0.1; // x will be 0.30000000000000004
Om het bovenstaande probleem op te lossen, helpt het om te vermenigvuldigen en te delen:
Voorbeeld
var x = (0.2 * 10 + 0.1 * 10) / 10; // x will be 0.3
WAARSCHUWING !!
JavaScript gebruikt de operator + voor zowel optellen als samenvoegen.
Nummers worden toegevoegd. Strings worden aan elkaar geplakt.
Als je twee getallen optelt, is het resultaat een getal:
Voorbeeld
var x = 10;
var y = 20;
var z = x + y; // z will be 30 (a number)
Als je twee strings toevoegt, is het resultaat een aaneenschakeling van tekenreeksen:
Voorbeeld
var x = "10";
var y = "20";
var z = x + y; // z will be 1020 (a string)
Als je een getal en een string toevoegt, is het resultaat een aaneenschakeling van een string:
Voorbeeld
var x = 10;
var y = "20";
var z = x + y; // z will be 1020 (a string)
Als je een string en een getal toevoegt, is het resultaat een aaneenschakeling van een string:
Voorbeeld
var x = "10";
var y = 20;
var z = x + y; // z will be 1020 (a string)
Een veelgemaakte fout is dat dit resultaat 30 is:
Voorbeeld
var x = 10;
var y = 20;
var z = "The result is: " + x + y; // z will be: The result is: 1020
Om dit op te lossen kun je haakjes gebruiken:
Voorbeeld
var x = 10;
var y = 20;
var z = "The result is: " + (x + y); // z will be: The result is: 30
Een veelgemaakte fout is dat dit resultaat 102030 is:
Voorbeeld
var x = 10;
var y = 20;
var z = "30";
var result = x + y + z; // z will be: 3030
De JavaScript-interpreter werkt van links naar rechts.
De eerste 10 + 20 wordt opgeteld omdat x en y beide getallen zijn.
Dan wordt 30 + "30" aaneengeschakeld omdat z een string is.
Numerieke tekenreeksen
JavaScript-strings kunnen numerieke inhoud hebben:
var x = 100; // x is a number
var y = "100"; // y is a string
JavaScript zal proberen om strings naar getallen om te zetten in alle numerieke bewerkingen behalve optellen:
Dit zal werken:
var x = "100";
var y = "10";
var z = x / y; // z will be 10
Dit werkt ook:
var x = "100";
var y = "10";
var z = x * y; // z will be 1000
En dit zal werken:
var x = "100";
var y = "10";
var z = x - y; // z will be 90
Maar dit zal niet werken:
var x = "100";
var y = "10";
var z = x + y; // z will not be 110 (It will be 10010)
In het laatste voorbeeld gebruikt JavaScript de + operator om de strings samen te voegen.
NaN is een door JavaScript gereserveerd woord dat aangeeft dat een nummer geen geldig nummer is.
Als je probeert te rekenen met een niet-numerieke reeks, krijgt je NaN(Geen getal):
Voorbeeld
var x = 100 / "Apple"; // x will be NaN (Not a Number)
Als de tekenreeks echter een numerieke waarde bevat, is het resultaat een getal:
Voorbeeld
var x = 100 / "10"; // x will be 10
U kunt de algemene JavaScript-functie gebruiken isNaN() om erachter te komen of een waarde een getal is:
Voorbeeld
var x = 100 / "Apple";
isNaN(x); // returns true because x is Not a Number
Pas op voor NaN. Als je NaN in een wiskundige bewerking gebruikt, is het resultaat ook NaN:
Voorbeeld
var x = NaN;
var y = 5;
var z = x + y; // z will be NaN
Of het resultaat kan een aaneenschakeling zijn:
Voorbeeld
var x = NaN;
var y = "5";
var z = x + y; // z will be NaN5
NaN is een getal: typeof NaN geeft als resultaat number:
Voorbeeld
typeof NaN; // returns "number"
Infinity(of -Infinity) is de waarde die JavaScript zal retourneren als je een getal berekent dat buiten het grootst mogelijke getal ligt.
Voorbeeld
var myNumber = 2;
while (myNumber != Infinity) { // Execute until Infinity
myNumber = myNumber * myNumber;
}
Deling door 0 (nul) genereert ook Infinity:
Voorbeeld
var x = 2 / 0; // x will be Infinity
var y = -2 / 0; // y will be -Infinity
Infinity is een getal: typeof Infinity retourneert number.
Voorbeeld
typeof Infinity; // returns "number"
JavaScript interpreteert numerieke constanten als hexadecimaal als ze worden voorafgegaan door 0x
.
Voorbeeld
var x = 0xFF; // x will be 255
Schrijf nooit een getal met een voorloop nul (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 je kunt de toString() methode gebruiken om getallen uit te voeren van basis 2 tot basis 36 .
Voorbeeld
var myNumber = 32;
myNumber.toString(10); // returns 32
myNumber.toString(32); // returns 10
myNumber.toString(16); // returns 20
myNumber.toString(8); // returns 40
myNumber.toString(2); // returns 100000
Normaal gesproken zijn JavaScript-nummers primitieve waarden die zijn gemaakt op basis van letterlijke waarden:
var x = 123;
Maar getallen kunnen ook worden gedefinieerd als objecten met het trefwoord new:
var y = new Number(123);
Voorbeeld
var x = 123;
var y = new Number(123);
// typeof x returns number
// typeof y returns object
Maak geen Number-objecten. Het vertraagt de uitvoeringssnelheid.
Het new sleutelwoord maakt de code ingewikkelder. Dit kan enkele onverwachte resultaten opleveren:
Bij gebruik van de ==
operator zijn gelijke getallen gelijk:
Voorbeeld
var x = 500;
var y = new Number(500);
// (x == y) is true because x and y have equal values
Bij gebruik van de ===
operator zijn gelijke getallen niet gelijk, omdat de ===
operator gelijkheid verwacht in zowel type als waarde.
Voorbeeld
var x = 500;
var y = new Number(500);
// (x === y) is false because x and y have different types
Of nog erger. Objecten kunnen niet worden vergeleken:
Voorbeeld
var x = new Number(500);
var y = new Number(500);
// (x == y) is false because objects cannot be compared
Let op het verschil tussen (x==y
)en (x===y
).
Het vergelijken van twee JavaScript-objecten zal altijd terugkeren false.
Primitieve waarden (zoals 3.14 van 2014) kunnen geen eigenschappen en methoden hebben (omdat het geen objecten zijn).
Maar in JavaScript zijn methoden en eigenschappen ook beschikbaar voor primitieve waarden, omdat JavaScript primitieve waarden als objecten behandelt bij het uitvoeren van methoden en eigenschappen.
De toString()
methode retourneert een getal als een tekenreeks.
Alle nummermethoden kunnen worden gebruikt voor elk type nummer (literals, variabelen of uitdrukkingen):
Voorbeeld
var x = 123;
x.toString(); // returns 123 from variable x
(123).toString(); // returns 123 from literal 123
(100 + 23).toString(); // returns 123 from expression 100 + 23
toExponential()
geeft een tekenreeks terug, met een getal afgerond en geschreven in exponentiële notatie.
Een parameter definieert het aantal tekens achter de komma:
Voorbeeld
var x = 9.656;
x.toExponential(2); // returns 9.66e+0
x.toExponential(4); // returns 9.6560e+0
x.toExponential(6); // returns 9.656000e+0
De parameter is optioneel. Als je dit niet opgeeft, rondt JavaScript het getal niet af.
toFixed()
geeft een tekenreeks terug, met het getal geschreven met een opgegeven aantal decimalen:
Voorbeeld
var x = 9.656;
x.toFixed(0); // returns 10
x.toFixed(2); // returns 9.66
x.toFixed(4); // returns 9.6560
x.toFixed(6); // returns 9.656000
toFixed(2)
is perfect als je met geld werkt.
toPrecision()
geeft een tekenreeks terug, met een getal geschreven met een opgegeven lengte:
Voorbeeld
var x = 9.656;
x.toPrecision(); // returns 9.656
x.toPrecision(2); // returns 9.7
x.toPrecision(4); // returns 9.656
x.toPrecision(6); // returns 9.65600
valueOf()
geeft een getal terug als een getal.
Voorbeeld
var x = 123;
x.valueOf(); // returns 123 from variable x
(123).valueOf(); // returns 123 from literal 123
(100 + 23).valueOf(); // returns 123 from expression 100 + 23
In JavaScript kan een getal een primitieve waarde zijn (typeof = getal) of een object (typeof = object). De valueOf()
methode wordt intern in JavaScript gebruikt om Number-objecten naar primitieve waarden te converteren. Er is geen reden om het in uw code te gebruiken.
Alle JavaScript-gegevenstypen hebben een valueOf()
en een toString()
methode.
Er zijn 3 JavaScript-methoden die kunnen worden gebruikt om variabelen in getallen om te zetten:
Deze methoden zijn niet nummer speciefieke methoden, maar globale JavaScript-methoden.
Number()
kan worden gebruikt om JavaScript-variabelen om te zetten in getallen:
Voorbeeld
Number(true); // returns 1
Number(false); // returns 0
Number("10"); // returns 10
Number(" 10"); // returns 10
Number("10 "); // returns 10
Number(" 10 "); // returns 10
Number("10.33"); // returns 10.33
Number("10,33"); // returns NaN
Number("10 33"); // returns NaN
Number("John"); // returns NaN
Als het nummer niet kan worden geconverteerd, wordt NaN (Not a Number) geretourneerd.
Number() kan ook een datum naar een getal converteren:
Voorbeeld
Number(new Date("2017-09-30")); // returns 1506729600000
De Number()
methode retourneert het aantal milliseconden sinds 01-01-1970.
parseInt()
parsed een string en retourneert een geheel getal. Spaties zijn toegestaan. Alleen het eerste nummer wordt geretourneerd:
Voorbeeld
parseInt("10"); // returns 10
parseInt("10.33"); // returns 10
parseInt("10 20 30"); // returns 10
parseInt("10 years"); // returns 10
parseInt("years 10"); // returns NaN
Als het nummer niet kan worden geconverteerd, wordt NaN (Not a Number) geretourneerd.
parseFloat()
parsed een string en retourneert een getal. Spaties zijn toegestaan. Alleen het eerste nummer wordt geretourneerd:
Voorbeeld
parseFloat("10"); // returns 10
parseFloat("10.33"); // returns 10.33
parseFloat("10 20 30"); // returns 10
parseFloat("10 years"); // returns 10
parseFloat("years 10"); // returns NaN
Als het nummer niet kan worden geconverteerd, wordt NaN (Not a Number) geretourneerd.