In deze tutorial leert u aan de hand van voorbeelden over JavaScript Number.
In JavaScript zijn getallen primitieve gegevenstypen. Bijvoorbeeld,
const a = 3; const b = 3.13;
In tegenstelling tot sommige andere programmeertalen, hoeft u niet specifiek voor integer of zwevende waarden te declareren met int , float , etc.
U kunt exponentiële notatie e gebruiken om te grote of te kleine getallen op te nemen. Bijvoorbeeld,
const a1 = 5e9; console.log(a1); //5000000000 const a2 = 5e-5; console.log(a2); // 0.00005
Getallen kunnen ook in hexadecimale notatie worden weergegeven. Bijvoorbeeld,
const a = 0xff; console.log(a); // 255 const b = 0x00 ; console.log(b); // 0
+ Operator met cijfers
Wanneer +wordt gebruikt met cijfers, wordt het gebruikt om de nummers toe te voegen. Bijvoorbeeld,
const a = 4 + 9; console.log(a); // 13
Wanneer +wordt gebruikt met getallen en tekenreeksen, wordt het gebruikt om ze samen te voegen. Bijvoorbeeld,
const a = '4' + 9; console.log(a); // 49
Wanneer een numerieke reeks wordt gebruikt met andere numerieke bewerkingen, wordt de numerieke reeks omgezet in een getal. Bijvoorbeeld,
const a = '4' - 2; console.log(a); // 2 const a = '4' / 2; console.log(a); // 2 const a = '4' * 2; console.log(a); // 8
JavaScript NaN
In JavaScript is NaN(Not a Number) een trefwoord dat aangeeft dat de waarde geen getal is.
Het uitvoeren van rekenkundige bewerkingen (behalve +) naar een numerieke waarde met tekenreeks resulteert in NaN. Bijvoorbeeld,
const a = 4 - 'hello'; console.log(a); // NaN
De ingebouwde functie isNaN()kan worden gebruikt om te zoeken of een waarde een getal is. Bijvoorbeeld,
const a = isNaN(9); console.log(a); // false const a = isNaN(4 - 'hello'); console.log(a); // true
Als de typeofoperator wordt gebruikt voor NaNwaarde, geeft dit een getaluitvoer. Bijvoorbeeld,
const a = 4 - 'hello'; console.log(a); // NaN console.log(typeof a); // "number"
JavaScript Infinity
In JavaScript wordt, wanneer een berekening wordt uitgevoerd die het grootst (of kleinst) mogelijke aantal overschrijdt, Infinity (of -Infinity) geretourneerd. Bijvoorbeeld,
const a = 2 / 0; console.log(a); // Infinity const a = -2 / 0; console.log(a); // -Infinity
JavaScript BigInt
In JavaScript kan het nummertype alleen getallen vertegenwoordigen kleiner dan (2 53 - 1) en meer dan - (2 53 - 1) . Als u echter een groter aantal moet gebruiken, kunt u het gegevenstype BigInt gebruiken.
Een BigInt-nummer wordt gemaakt door n toe te voegen aan het einde van een geheel getal. Bijvoorbeeld,
// BigInt value const value = 900719925124740998n; // Adding two big integers const value1 = value + 1n; console.log(value1); // returns "900719925124740999n"
Opmerking: BigInt is geïntroduceerd in de nieuwere versie van JavaScript en wordt niet door veel browsers ondersteund. Bezoek JavaScript BigInt-ondersteuning voor meer informatie.
JavaScript-nummers worden opgeslagen in 64-bits
In JavaScript worden getallen opgeslagen in 64-bits formaat IEEE-754, ook wel bekend als "dubbele precisie drijvende-kommagetallen".
De nummers worden opgeslagen in 64 bits (het nummer wordt opgeslagen in posities van 0 tot 51 bit, de exponent in posities van 52 tot 62 bit en het teken in posities van 63 bit).
| Getallen | Exponent | Teken |
|---|---|---|
| 52 bits (0 - 51) | 11 bits (52-62) | 1 beetje (63) |
Precisieproblemen
Bewerkingen op getallen met drijvende komma resulteren in enkele onverwachte resultaten. Bijvoorbeeld,
const a = 0.1 + 0.2; console.log(a); // 0.30000000000000004
Het resultaat moet 0,3 zijn in plaats van 0,30000000000000004 . Deze fout treedt op omdat in JavaScript getallen in binaire vorm worden opgeslagen om intern decimale cijfers weer te geven. En decimale getallen kunnen niet exact in binaire vorm worden weergegeven.
Om het bovenstaande probleem op te lossen, kunt u zoiets als dit doen:
const a = (0.1 * 10 + 0.2 * 10) / 10; console.log(a); // 0.3
U kunt ook de toFixed()methode gebruiken.
const a = 0.1 + 0.2; console.log(a.toFixed(2)); // 0.30
toFixed(2) rondt het decimale getal naar boven af op twee decimale waarden.
const a = 9999999999999999 console.log(a); // 10000000000000000
Opmerking : gehele getallen zijn nauwkeurig tot 15 cijfers.
Nummer objecten
U kunt ook nummers maken met behulp van het newtrefwoord. Bijvoorbeeld,
const a = 45; // creating a number object const b = new Number(45); console.log(a); // 45 console.log(b); // 45 console.log(typeof a); // "number" console.log(typeof b); // "object"
Opmerking : het wordt aanbevolen om geen nummerobjecten te gebruiken. Het gebruik van nummerobjecten vertraagt het programma.
JavaScript-cijfermethoden
Hier is een lijst met ingebouwde cijfermethoden in JavaScript.
| Methode | Omschrijving |
|---|---|
| isNaN () | bepaalt of de doorgegeven waarde NaN is |
| isFinite () | bepaalt of de doorgegeven waarde een eindig getal is |
| isGeheel getal () | bepaalt of de doorgegeven waarde een geheel getal is |
| isSafeInteger () | bepaalt of de doorgegeven waarde een veilig geheel getal is |
| parseFloat (tekenreeks) | converteert de numerieke zwevende tekenreeks naar een getal met een drijvende komma |
| parseInt (string, (radix)) | converteert de numerieke tekenreeks naar een geheel getal |
| toExponential (fractionDigits) | returns a string value for a number in exponential notation |
| toFixed(digits) | returns a string value for a number in fixed-point notation |
| toPrecision() | returns a string value for a number to a specified precision |
| toString((radix)) | returns a string value in a specified radix(base) |
| valueof() | returns the numbers value |
| toLocaleString() | returns a string with a language sensitive representation of a number |
For example,
// check if a is integer const a = 12; console.log(Number.isInteger(a)); // true // check if b is NaN const b = NaN; console.log(Number.isNaN(b)); // true // display upto two decimal point const d = 5.1234; console.log(d.toFixed(2)); // 5.12
JavaScript Number Properties
Here is a list of Number properties in JavaScript.
| Property | Description |
|---|---|
| EPSILON | returns the smallest interval between two representable numbers |
| MAX_SAFE_INTEGER | returns the maximum safe integer |
| MAX_VALUE | returns the largest possible value |
| MIN_SAFE_INTEGER | returns the minimum safe integer |
| MIN_VALUE | returns the smallest possible value |
| NaN | represents 'Not-a-Number' value |
| NEGATIVE_INFINITY | represents negative infinity |
| POSITIVE_INFINITY | staat voor positieve oneindigheid |
| voorlopig ontwerp | maakt het toevoegen van eigenschappen aan Number-objecten mogelijk |
Bijvoorbeeld,
// largest possible value const a = Number.MAX_VALUE; console.log(a); // 1.7976931348623157e+308 // maximum safe integer const a = Number.MAX_SAFE_INTEGER; console.log(a); // 9007199254740991
JavaScript-nummer () functie
De Number()functie wordt gebruikt om verschillende gegevenstypen om te zetten in getallen. Bijvoorbeeld,
const a = '23'; // string const b = true; // boolean //converting to number const result1 = Number(a); const result2 = Number(b); console.log(result1); // 23 console.log(result2); // 1
Ga naar JavaScript Type Conversion als u meer wilt weten over de nummerconversie.
