JavaScript Numbers

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

Probeer het zelf

Supergrote of supersmalle getallen kunnen worden geschreven met wetenschappelijke notatie:

Voorbeeld

var x = 123e5;    // 12300000
var y = 123e-5;   // 0.00123

Probeer het zelf

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

Probeer het zelf

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

Probeer het zelf

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

Probeer het zelf

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)

Probeer het zelf

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

Probeer het zelf

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)

Probeer het zelf

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

Probeer het zelf

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;

Probeer het zelf

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;

Probeer het zelf

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

Probeer het zelf

Dit voorbeeld werkt ook zo:

var x = "100";
var y = "10";
var z = x * y;       // z zal 1000 zijn

Probeer het zelf

Dit voorbeeld werkt echter zo:

var x = "100";
var y = "10";
var z = x - y;      // z zal 90 zijn

Probeer het zelf

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)

Probeer het zelf

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

Probeer het zelf

Maar als de string een getal bevat, zal het resultaat een getal zijn:

Voorbeeld

var x = 100 / "10";     // x zal 10 zijn

Probeer het zelf

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

Probeer het zelf

wees voorzichtig NaNAls u een wiskundige berekening uitvoert met NaNdan zal het resultaat ook zijn NaN:

Voorbeeld

var x = NaN;
var y = 5;
var z = x + y;         // z zal NaN zijn

Probeer het zelf

het resultaat kan zijn een stringkoppeling:

Voorbeeld

var x = NaN;
var y = "5";
var z = x + y;         // z zal NaN5 zijn

Probeer het zelf

NaN is een getal,typeof NaN keert number:

Voorbeeld

typeof NaN;             // Keert "number" terug

Probeer het zelf

Infinity

Infinity of -Infinityis 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;
}

Probeer het zelf

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

Probeer het zelf

Infinity is een getal:typeOf Infinity keert number.

Voorbeeld

typeof Infinity;        // Keert "number" terug

Probeer het zelf

hexadecimaal

JavaScript zet getallen met de voorvoegsel 0x de getalconstante als hexadecimaal.

Voorbeeld

var x = 0xFF;             // x zal 255 zijn.

Probeer het zelf

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

Probeer het zelf

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

Probeer het zelf

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

Probeer het zelf

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

Probeer het zelf

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

Probeer het zelf

JavaScript-objecten kunnen niet worden vergeleken.