I denna handledning lär du dig om JavaScript-nummer med hjälp av exempel.
I JavaScript är siffror primitiva datatyper. Till exempel,
const a = 3; const b = 3.13;
Till skillnad från i vissa andra programmeringsspråk behöver du inte specifikt deklarera för heltal eller flytande värden med int , float , etc.
Du kan använda exponentiell notation e för att inkludera för stora eller för små siffror. Till exempel,
const a1 = 5e9; console.log(a1); //5000000000 const a2 = 5e-5; console.log(a2); // 0.00005
Siffror kan också betecknas i hexadecimal notation. Till exempel,
const a = 0xff; console.log(a); // 255 const b = 0x00 ; console.log(b); // 0
+ Operatör med siffror
När den +används med siffror används den för att lägga till siffrorna. Till exempel,
const a = 4 + 9; console.log(a); // 13
När den +används med siffror och strängar används den för att sammanfoga dem. Till exempel,
const a = '4' + 9; console.log(a); // 49
När en numerisk sträng används med andra numeriska operationer konverteras den numeriska strängen till ett tal. Till exempel,
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
I JavaScript är NaN(Inte ett nummer) ett nyckelord som anger att värdet inte är ett nummer.
Utför aritmetiska operationer (förutom +) till numeriskt värde med sträng resulterar i NaN. Till exempel,
const a = 4 - 'hello'; console.log(a); // NaN
Den inbyggda funktionen isNaN()kan användas för att hitta om ett värde är ett tal. Till exempel,
const a = isNaN(9); console.log(a); // false const a = isNaN(4 - 'hello'); console.log(a); // true
När typeofoperatören används för NaNvärde, ger den en siffra. Till exempel,
const a = 4 - 'hello'; console.log(a); // NaN console.log(typeof a); // "number"
JavaScript Infinity
I JavaScript returneras Infinity (eller -Infinity) när beräkning görs som överstiger det största (eller minsta möjliga antalet ). Till exempel,
const a = 2 / 0; console.log(a); // Infinity const a = -2 / 0; console.log(a); // -Infinity
JavaScript BigInt
I JavaScript kan nummertyp endast representera siffror mindre än (2 53 - 1) och mer än - (2 53 - 1) . Men om du behöver använda ett större antal än så kan du använda datatypen BigInt.
Ett BigInt-nummer skapas genom att lägga till n i slutet av ett heltal. Till exempel,
// BigInt value const value = 900719925124740998n; // Adding two big integers const value1 = value + 1n; console.log(value1); // returns "900719925124740999n"
Obs! BigInt introducerades i den nyare versionen av JavaScript och stöds inte av många webbläsare. Besök JavaScript BigInt support för att lära dig mer.
JavaScript-nummer lagras i 64-bitars
I JavaScript lagras nummer i 64-bitarsformat IEEE-754, även känt som "flytande punktnummer med dubbel precision".
Siffrorna lagras i 64 bitar (numret lagras i 0 till 51 bit positioner, exponenten i 52 till 62 bit positioner och tecknet i 63 bit position).
| Tal | Exponent | Skylt |
|---|---|---|
| 52 bitar (0 - 51) | 11 bitar (52-62) | 1 bit (63) |
Precisionsproblem
Operationer på flytande siffror resulterar i några oväntade resultat. Till exempel,
const a = 0.1 + 0.2; console.log(a); // 0.30000000000000004
Resultatet ska vara 0,3 istället för 0,30000000000000004 . Det här felet uppstår eftersom siffror i JavaScript lagras i binär form för att representera decimalsiffror internt. Och decimaltal kan inte representeras exakt i binär form.
För att lösa ovanstående problem kan du göra något liknande:
const a = (0.1 * 10 + 0.2 * 10) / 10; console.log(a); // 0.3
Du kan också använda toFixed()metoden.
const a = 0.1 + 0.2; console.log(a.toFixed(2)); // 0.30
toFixed(2) avrundar decimaltal till två decimalvärden.
const a = 9999999999999999 console.log(a); // 10000000000000000
Obs! Heltal är exakt upp till 15 siffror.
Antal objekt
Du kan också skapa nummer med hjälp av newnyckelordet. Till exempel,
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"
Obs! Det rekommenderas att du undviker att använda nummerobjekt. Att använda nummerobjekt saktar ner programmet.
JavaScript-nummermetoder
Här är en lista över inbyggda nummermetoder i JavaScript.
| Metod | Beskrivning |
|---|---|
| isNaN () | bestämmer om det godkända värdet är NaN |
| isFinite () | avgör om det godkända värdet är ett slutligt tal |
| isInteger () | avgör om det godkända värdet är ett heltal |
| isSafeInteger () | avgör om det godkända värdet är ett säkert heltal |
| parseFloat (sträng) | konverterar den numeriska flytande strängen till flytpunkt |
| parseInt (sträng, (radix)) | konverterar den numeriska strängen till heltal |
| 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 | representerar positiv oändlighet |
| prototyp | tillåter tillägg av egenskaper till Number-objekt |
Till exempel,
// 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 () -funktion
Den Number()funktionen används för att konvertera olika datatyper till siffror. Till exempel,
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
Om du vill lära dig mer om nummerkonvertering, besök JavaScript Type Conversion.
