JavaScript -nommers
JavaScript het net een tipe nommer. Getalle kan met of sonder desimale geskryf word.
Voorbeeld
let x = 3.14; // A number with decimals
let y = 3; // A number without decimals
Ekstra groot of ekstra klein getalle kan met wetenskaplike (eksponent) notasie geskryf word:
Voorbeeld
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
JavaScript-nommers is altyd 64-bis drywende punt
Anders as baie ander programmeertale, definieer JavaScript nie verskillende tipes getalle nie, soos heelgetalle, kort, lank, drywende punt, ens.
JavaScript-nommers word altyd gestoor as dubbel-presisie swaaipuntnommers, volgens die internasionale IEEE 754-standaard.
Hierdie formaat stoor getalle in 64 bisse, waar die getal (die breuk) in bisse 0 tot 51 gestoor word, die eksponent in bisse 52 tot 62, en die teken in bisse 63:
| Waarde (ook bekend as breuk/mantisse) | Eksponent | Teken |
|---|---|---|
| 52 bisse (0 - 51) | 11 bisse (52 - 62) | 1 bis (63) |
Heelgetal akkuraatheid
Heelgetalle (getalle sonder 'n punt of eksponentnotasie) is akkuraat tot 15 syfers.
Voorbeeld
let x = 999999999999999; // x will be 999999999999999
let y = 9999999999999999; // y will be 10000000000000000
Die maksimum aantal desimale is 17.
Swaai presisie
Wisselpuntrekenkunde is nie altyd 100% akkuraat nie:
let x = 0.2 + 0.1;
Om die probleem hierbo op te los, help dit om te vermenigvuldig en te deel:
let x = (0.2 * 10 + 0.1 * 10) / 10;
Voeg getalle en stringe by
WAARSKUWING!!
JavaScript gebruik die + operateur vir beide byvoeging en aaneenskakeling.
Getalle word bygevoeg. Strings is aaneengeskakel.
As jy twee getalle bytel, sal die resultaat 'n getal wees:
Voorbeeld
let x = 10;
let y = 20;
let z = x + y;
As jy twee stringe byvoeg, sal die resultaat 'n string aaneenskakeling wees:
Voorbeeld
let x = "10";
let y = "20";
let z = x + y;
As jy 'n nommer en 'n string byvoeg, sal die resultaat 'n string aaneenskakeling wees:
Voorbeeld
let x = 10;
let y = "20";
let z = x + y;
As jy 'n string en 'n nommer byvoeg, sal die resultaat 'n string aaneenskakeling wees:
Voorbeeld
let x = "10";
let y = 20;
let z = x + y;
'n Algemene fout is om te verwag dat hierdie resultaat 30 sal wees:
Voorbeeld
let x = 10;
let y = 20;
let z = "The result is: " + x + y;
'n Algemene fout is om te verwag dat hierdie resultaat 102030 sal wees:
Voorbeeld
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
Die JavaScript-tolk werk van links na regs.
Eerste 10 + 20 word bygevoeg omdat x en y albei getalle is.
Dan word 30 + "30" aaneengeskakel omdat z 'n string is.
Numeriese snare
JavaScript-stringe kan numeriese inhoud hê:
let x = 100; // x is a number
let y = "100"; // y is a
string
JavaScript sal probeer om stringe na getalle om te skakel in alle numeriese bewerkings:
Dit sal werk:
let x = "100";
let y = "10";
let z = x / y;
Dit sal ook werk:
let x = "100";
let y = "10";
let z = x * y;
En dit sal werk:
let x = "100";
let y = "10";
let z = x - y;
Maar dit sal nie werk nie:
let x = "100";
let y = "10";
let z = x + y;
In die laaste voorbeeld gebruik JavaScript die + operateur om die stringe aaneen te koppel.
NaN - Nie 'n nommer nie
NaNis 'n JavaScript-gereserveerde woord wat aandui dat 'n nommer nie 'n wettige nommer is nie.
Om rekenkunde met 'n nie-numeriese string te probeer doen, sal lei tot NaN(Nie 'n Getal nie):
Voorbeeld
let x = 100 / "Apple";
As die string egter 'n numeriese waarde bevat, sal die resultaat 'n getal wees:
Voorbeeld
let x = 100 / "10";
Jy kan die globale JavaScript-funksie isNaN()
gebruik om uit te vind of 'n waarde nie 'n getal is nie:
Voorbeeld
let x = 100 / "Apple";
isNaN(x);
Pasop vir NaN. As jy NaNin 'n wiskundige bewerking gebruik, sal die resultaat ook wees NaN:
Voorbeeld
let x = NaN;
let y = 5;
let z = x + y;
Of die resultaat kan 'n aaneenskakeling soos NaN5 wees:
Voorbeeld
let x = NaN;
let y = "5";
let z = x + y;
NaNis 'n getal: typeof NaNgee terug number:
Voorbeeld
typeof NaN;
Oneindigheid
Infinity(of -Infinity) is die waarde wat JavaScript sal terugstuur as jy 'n getal buite die grootste moontlike getal bereken.
Voorbeeld
let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
}
Deling deur 0 (nul) genereer ook Infinity:
Voorbeeld
let x = 2 / 0;
let y = -2 / 0;
Infinityis 'n getal: typeof Infinitygee terug number.
Voorbeeld
typeof Infinity;
Heksadesimale
JavaScript interpreteer numeriese konstantes as heksadesimale as hulle voorafgegaan word deur 0x.
Voorbeeld
let x = 0xFF;
Moet nooit 'n getal met 'n voorste nul skryf nie (soos 07).
Sommige JavaScript-weergawes interpreteer getalle as oktaal as hulle met 'n voorste nul geskryf word.
JavaScript vertoon by verstek getalle as basis 10 desimale.
Maar jy kan die toString()metode gebruik om getalle van basis 2
na basis 36 uit te voer .
Heksadesimale is basis 16 . Desimale is basis 10 . Oktaal is basis 8 . Binêr is basis 2 .
Voorbeeld
let myNumber = 32;
myNumber.toString(10);
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(8);
myNumber.toString(2);
JavaScript-nommers as objekte
Normaalweg is JavaScript-nommers primitiewe waardes wat uit letterlike woorde geskep word:
let x = 123;
Maar getalle kan ook gedefinieer word as voorwerpe met die sleutelwoord new:
let y = new Number(123);
Voorbeeld
let x = 123;
let y = new Number(123);
Moenie Number-objekte skep nie.
Die newsleutelwoord kompliseer die kode en vertraag die uitvoeringspoed.
Getalvoorwerpe kan onverwagte resultate lewer:
Wanneer die ==operateur gebruik word, is x en y gelyk :
let x = 500;
let y = new Number(500);
Wanneer die ===operateur gebruik word, is x en y nie gelyk nie .
let x = 500;
let y = new Number(500);
Let op die verskil tussen (x==y)en (x===y).
(x == y) waar of onwaar?
let x = new Number(500);
let y = new Number(500);
(x === y) waar of onwaar?
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.