Numbers

Werken met getallen is heel belangrijk in elke programmeertaal. Intern zullen computers verschillende typen getallen (gehele getallen, drijvende komma getallen etc.) op verschillende manieren behandelen, dus veel programmeertalen zullen hetzelfde doen als jij, maar met JavaScript ben je vrij om verschillende soorten getallen te mixen en matchen.

Werken met getallen

Dus bijvoorbeeld, een variabele maken met een geheel getal is zo eenvoudig als het definiëren ervan en het getal eraan toewijzen:

let n = 42;

En als u een getal met drijvende komma wilt, geen probleem - dat kan net zo gemakkelijk. Gebruik gewoon een punt om het hele getal en het decimale deel te scheiden, zoals dit:

let n = 42.123;

This also means that you are free to do math with integers and floating point numbers as if they are the same type, which makes things a lot easier. Here's an example:

let n1 = 2, n2 = 40.123;
alert(n1 + n2);

Numeriek scheidingsteken

Bij het definiëren van grote getallen kan het moeilijk zijn om te zien hoe groot de getallen zijn bij het lezen van de code:

let n1 = 42000000000;

JavaScript kan hier helpen, met een beetje syntactische suiker in de vorm van het numerieke scheidingsteken - je bent vrij om underscores toe te voegen om groepen cijfers te maken:

let n1 = 42_000_000_000;
alert(n1);

Tekenreeksen omzetten naar getallen

Soms wil je iets dat eigenlijk een tekststring is omzetten in een getal. Daarvoor zijn er twee algemeen beschikbare functies: parseInt() en parseFloat(). Hun namen spreken voor zich - ze nemen gewoon een tekststring en zetten die, indien mogelijk, om in een getal, ervan uitgaande dat de tekststring de vorm heeft van een geheel getal of een getal met drijvende komma.

let n1 = "40", n2 = "2.42";
alert(parseInt(n1) + parseFloat(n2));

Als we ze niet eerst omzetten in getallen, zou JavaScript denken dat we twee tekenreeksen aan elkaar proberen te rijgen, wat resulteert in de waarde 402.42 in plaats van het gewenste resultaat van 42.42.

Als alternatief kun je de methode Getal() gebruiken - deze probeert elk type invoer te nemen en het te converteren naar een getal:

let n1 = "40", n2 = "2.42";
alert(Number(n1) + Number(n2));

Geen getal (NaN)

Hoewel JavaScript erg flexibel is in het omgaan met getallen, zullen er situaties zijn waarin je er absoluut zeker van wilt zijn dat de waarde die je vasthoudt een getal is, of zou kunnen zijn. JavaScript heeft hiervoor een specifieke, globaal beschikbare constante, genaamd NaN (afkorting van Not a Number). Deze wordt door verschillende JavaScript-functies geretourneerd als je iets probeert te doen waarvan verwacht wordt dat het een numeriek resultaat oplevert, maar dit niet mogelijk is. Een voorbeeld:

alert(parseInt("forty two"));

Hier wordt verwacht dat de parseInt() functie een getal teruggeeft, maar "tweeënveertig" is niet echt een geldig getal, dus om aan te geven dat dit niet mogelijk was, wordt in plaats daarvan NaN teruggegeven. Dit betekent ook dat je soms moet controleren op NaN, om er zeker van te zijn dat het resultaat van een bewerking in feite een getal was. Hier moet je de wereldwijd beschikbare functie isNaN() gebruiken, die je simpelweg vertelt of de doorgegeven waarde "geen getal is".

let n1 = parseInt("forty two");
if(isNaN(n1))
	alert("Sorry, that's not a valid number!");
else
	alert("Cool number!");

BigInt

Normale getallen in JavaScript zijn enigszins beperkt in hoe groot of klein ze kunnen zijn. Wanneer je te maken hebt met gehele getallen, heeft het reguliere getaltype een minimum- en een maximumwaarde, die je altijd kunt controleren door de constanten Number.MIN_SAFE_INTEGER en Number.MAX_SAFE_INTEGER te controleren, zoals dit:

alert(Number.MIN_SAFE_INTEGER);
alert(Number.MAX_SAFE_INTEGER);

Als je met grotere getallen dan dat moet werken, kun je het bigint type, gebruiken, ondersteund door het BigInt object. Je kunt een bigint type specificeren door de methode BigInt() aan te roepen of door het getal te postfixeren met een n, , zoals dit:

let bigNumber = 429007199254740991n;
alert(bigNumber);
alert(typeof bigNumber);

Voor de meeste taken zul je echter waarschijnlijk gewoon het nummertype kunnen gebruiken - het bigint-type is voor echt, echt grote getallen, zoals je kunt zien.

Samenvatting

Omgaan met getallen is een belangrijk onderdeel van vrijwel elke programmeertaak, en gelukkig voor ons heeft JavaScript veel functionaliteit om het ons gemakkelijk te maken.

Achter de schermen wordt bij het declareren van een getal, zoals we in veel van de voorbeelden in dit artikel hebben gedaan, een Getal-object gemaakt. Op dit object vind je nog meer getalgerelateerde functionaliteit, en we zullen dit allemaal bespreken in het hoofdstuk over ingebouwde objecten, in het bijzonder in het artikel over het Getal object.