JavaScript Numbers
- Vorige pagina JS string template
- Volgende pagina JS BigInt
JavaScript heeft maar één numerieke type.
Bij het schrijven van getallen kan de komma worden weggelaten.
JavaScript Nummer
Het schrijven van JavaScript-getallen kan zowel met als zonder decimalteken
Voorbeeld
var x = 3.14; // Getal met decimalteken var y = 3; // Getal zonder decimalteken
Supergrote of supersmalle getallen kunnen worden geschreven met wetenschappelijke notatie:
Voorbeeld
var x = 123e5; // 12300000 var y = 123e-5; // 0.00123
JavaScript-getallen zijn altijd 64 bits floating-point
In tegenstelling tot veel andere programmeertalen definieert JavaScript geen verschillende types getallen, zoals gehele getallen, korte, lange, floating-point, enz.
JavaScript slaat alle getallen altijd op als een dubbele precisie floating-point, volgens de internationale IEEE 754-norm.
Dit formaat slaat het getal op met 64 bits, waarbij 0 tot 51 het getal (fragment) opslaat, 52 tot 62 de index opslaat en 63 het signaal opslaat:
Waarde(ook wel Fraction/Mantissa genoemd) | Index | Signaal |
---|---|---|
52 bits(0 - 51) | 11 bits (52 - 62) | 1 bit (63) |
Nauwkeurigheid
Gehele getallen (zonder exponent of wetenschappelijke notatie) worden nauwkeurig tot 15 cijfers.
Voorbeeld
var x = 999999999999999; // x zal 999999999999999 zijn var y = 9999999999999999; // y zal 10000000000000000 zijn
Het maximale aantal decimale cijfers is 17, maar het floating-point rekenen is niet altijd 100% nauwkeurig:
Voorbeeld
var x = 0.2 + 0.1; // x zal 0.30000000000000004 zijn
Gebruik van vermenigvuldiging en deling kan helpen om het probleem op te lossen:
Voorbeeld
var x = (0.2 * 10 + 0.1 * 10) / 10; // x zal 0.3 zijn
Getal en string optellen
Waarschuwing!!
JavaScript gebruikt zowel optelling als ketting met de +-betekener.
Getallen gebruiken optelling. Strings gebruiken ketting.
Als je twee getallen optelt, is het resultaat een getal:
Voorbeeld
var x = 10; var y = 20; var z = x + y; // z zal 30 zijn (een getal)
Als je twee strings optelt, is het resultaat een stringketting:
Voorbeeld
var x = "10"; var y = "20"; var z = x + y; // z zal 1020 (een string) zijn
Als je een getal en een string optelt, is het resultaat ook een stringketting:
Voorbeeld
var x = 10; var y = "20"; var z = x + y; // z zal 1020 zijn (een string)
Als u een string en een getal optelt, resulteert dit ook in een string-cascade:
Voorbeeld
var x = "10"; var y = 20; var z = x + y; // z zal 1020 (een string) zijn
Een vaak gemaakte fout is het denken dat het resultaat 30 zou moeten zijn:
Voorbeeld
var x = 10; var y = 20; var z = "The result is: " + x + y;
Een vaak gemaakte fout is het denken dat het resultaat 102030 zou moeten zijn:
Voorbeeld
var x = 10; var y = 20; var z = "30"; var result = x + y + z;
JavaScript compilt van links naar rechts.
Omdat x en y beide getallen zijn, wordt 10 + 20 opgeteld.
Omdat z een string is, wordt 30 + "30" gecascadeerd.
Numerieke string
JavaScript-strings kunnen nummerieke inhoud bevatten:
var x = 100; // x is een getal var y = "100"; // y is een string
Bij alle getalberekeningen probeert JavaScript strings om te zetten naar getallen:
Dit voorbeeld werkt echter zo:
var x = "100"; var y = "10"; var z = x / y; // z zal 10 zijn
Dit voorbeeld werkt ook zo:
var x = "100"; var y = "10"; var z = x * y; // z zal 1000 zijn
Dit voorbeeld werkt echter zo:
var x = "100"; var y = "10"; var z = x - y; // z zal 90 zijn
Maar dit voorbeeld zal niet zoals hierboven lopen:
var x = "100"; var y = "10"; var z = x + y; // z zal niet 110 zijn (maar 10010)
In het laatste voorbeeld voegde JavaScript de string samen met het +-operator.
NaN - Niet een getal
NaN
is een voorbehouden woord in JavaScript, dat aangeeft dat een getal geen geldig getal is.
Een deling met een niet-getalige string resulteert in NaN (Not a Number):
Voorbeeld
var x = 100 / "Apple"; // x zal NaN (Not a Number) zijn
Maar als de string een getal bevat, zal het resultaat een getal zijn:
Voorbeeld
var x = 100 / "10"; // x zal 10 zijn
U kunt de globale JavaScript-functie gebruiken isNaN()
om te bepalen of een waarde een getal is:
Voorbeeld
var x = 100 / "Apple"; isNaN(x); // Retourne true, omdat x geen getal is
wees voorzichtig NaN
Als u een wiskundige berekening uitvoert met NaN
dan zal het resultaat ook zijn NaN
:
Voorbeeld
var x = NaN; var y = 5; var z = x + y; // z zal NaN zijn
het resultaat kan zijn een stringkoppeling:
Voorbeeld
var x = NaN; var y = "5"; var z = x + y; // z zal NaN5 zijn
NaN
is een getal,typeof NaN
keert number
:
Voorbeeld
typeof NaN; // Keert "number" terug
Infinity
Infinity
of -Infinity
is de waarde die JavaScript retourneert wanneer het bij het berekenen van getallen het bereik van de mogelijk grootste waarde overschrijdt.
Voorbeeld
var myNumber = 2; while (myNumber != Infinity) { // Voert uit tot Infinity myNumber = myNumber * myNumber; }
Het delen door 0 (nul) genereert ook Infinity
:
Voorbeeld
var x = 2 / 0; // x zal Infinity zijn var y = -2 / 0; // y zal -Infinity zijn
Infinity
is een getal:typeOf Infinity
keert number
.
Voorbeeld
typeof Infinity; // Keert "number" terug
hexadecimaal
JavaScript zet getallen met de voorvoegsel 0x
de getalconstante als hexadecimaal.
Voorbeeld
var x = 0xFF; // x zal 255 zijn.
Schrijf nooit cijfers met een voorvoegsel van nul (bijvoorbeeld 07).
Sommige versies van JavaScript interpreteren getallen met een voorvoegsel van nul als octaal.
Standaard toont Javascript getallen als decimale decimalen.
Maar u kunt ook toString()
De methode zet een getal om naar hexadecimaal, octaal of binair.
Voorbeeld
var myNumber = 128; myNumber.toString(16); // Keert 80 terug myNumber.toString(8); // Keert 200 terug myNumber.toString(2); // Keert 10000000 terug
Getallen kunnen ook objecten zijn
Doorgaans worden JavaScript-getallen gecreëerd door middel van een literaal: var x = 123
Maar het kan ook worden gedefinieerd met het keyword new
Gedefinieerd als object: var y = new Number(123)
Voorbeeld
var x = 123; var y = new Number(123); // typeof x retourneert number // typeof y retourneert object
Maak geen numerieke objecten. Dit kan de uitvoeringssnelheid vertragen.
new
Sleutelwoorden compliceren de code en kunnen onvoorspelbare resultaten veroorzaken:
Wanneer je ==
Gelijkheidsoperatoren maken getallen die er gelijk uitzien, eruit zien alsof ze gelijk zijn:
Voorbeeld
var x = 500; var y = new Number(500); // (x == y) is true omdat x en y dezelfde waarde hebben
Wanneer je ===
Na de gelijkheidsoperator worden gelijke getallen ongelijk omdat ===
Operatoren moeten zowel het type als de waarde gelijk zijn.
Voorbeeld
var x = 500; var y = new Number(500); // (x === y) is false omdat x en y van verschillende typen zijn
Zelfs erger. Objecten kunnen niet worden vergeleken:
Voorbeeld
var x = new Number(500); var y = new Number(500); // (x == y) is false omdat objecten niet kunnen worden vergeleken
JavaScript-objecten kunnen niet worden vergeleken.
- Vorige pagina JS string template
- Volgende pagina JS BigInt