Klassen `Number` i JavaScript

Denne artikkelen forklarer Number-klassen i JavaScript.

Vi vil grundig forklare egenskapene til Number, vanlige fallgruver, nyttige API-er og praktiske eksempler steg for steg.

YouTube Video

Klassen Number i JavaScript

Number er den grunnleggende numeriske typen i JavaScript og representeres som et IEEE-754 dobbeltpresisjons flyttall (64-bit).

Grunnleggende: Numerisk representasjon og typekontroll

I JavaScript er alle tall representert som den primitive typen number.

 1// Primitive numbers and Number object
 2const a = 42;                 // primitive number
 3const b = 3.14;               // primitive float
 4const c = Number(10);         // primitive via constructor call (function form)
 5const d = new Number(10);     // Number object (wrapper)
 6
 7console.log(typeof a);        // "number"
 8console.log(typeof d);        // "object"
 9console.log(c == d);          // true  (value coerces)
10console.log(c === d);         // false (different types)

• Denne koden viser forskjellen mellom en primitiv number og Number-innpakningsobjektet. Vanligvis brukes primitive typer i stedet for innpakkingsobjekter.

Spesielle verdier: NaN, Infinity, og konstanter

Number tilbyr spesielle verdier (NaN, Infinity) og konstanter.

 1// Special numeric values and constants
 2console.log(Number.NaN);                 // NaN
 3console.log(Number.POSITIVE_INFINITY);   // Infinity
 4console.log(Number.NEGATIVE_INFINITY);   // -Infinity
 5
 6console.log(Number.MAX_VALUE);           // largest positive representable
 7console.log(Number.MIN_VALUE);           // smallest positive representable (closest to 0)
 8console.log(Number.MAX_SAFE_INTEGER);    // 9007199254740991
 9console.log(Number.MIN_SAFE_INTEGER);    // -9007199254740991
10console.log(Number.EPSILON);             // smallest difference ~2.220446049250313e-16

• Heltall større enn eller lik MAX_SAFE_INTEGER kan ikke representeres nøyaktig. Vurder å bruke BigInt hvis nøyaktighet kreves. EPSILON brukes for sammenligning av flyttall.

Tallkonvertering: Number(), parseInt, parseFloat og +-operatoren

Det finnes flere måter å konvertere en streng til et tall på, hver med ulik oppførsel.

 1// Converting strings to numbers
 2console.log(Number("42"));        // 42
 3console.log(Number("  3.14 "));   // 3.14
 4console.log(+ "7");               // 7 (unary +)
 5
 6console.log(parseInt("42px"));    // 42
 7console.log(parseFloat("3.14abc"));// 3.14
 8
 9// Careful with parseInt and radix
10console.log(parseInt("08"));      // 8
11console.log(parseInt("08", 10));  // 8 (explicit radix is safer)

• Number() returnerer NaN med mindre hele strengen er i et strengt numerisk format, mens parseInt og parseFloat analyserer den lesbare, numeriske delen fra begynnelsen av strengen. Det er tryggere å alltid angi tallbasen (radix) eksplisitt når du bruker parseInt.

Håndtering og kontroll av NaN: isNaN og Number.isNaN

NaN (Not-A-Number) er spesiell fordi NaN !== NaN. De har ulike kontrollmetoder; globale isNaN utfører typekonvertering og kan føre til falske positiver, så Number.isNaN anbefales.

1// NaN detection differences
2console.log(NaN === NaN);             // false
3
4console.log(isNaN("foo"));            // true  -> because "foo" coerces to NaN
5console.log(Number.isNaN("foo"));     // false -> "foo" is not the numeric NaN
6
7console.log(Number.isNaN(NaN));       // true

• Bruk Number.isNaN for å sjekke tall og validere beregningsresultater for å unngå unødvendig typekonvertering.

Flyttallsfeil og sammenligninger med Number.EPSILON

På grunn av IEEE-754 oppstår feil som 0.1 + 0.2 !== 0.3. Ved strenge sammenligninger bruker man ofte differansen og Number.EPSILON.

1// Floating point precision example and EPSILON comparison
2const sum = 0.1 + 0.2;
3console.log(sum === 0.3);             // false
4
5function nearlyEqual(a, b, epsilon = Number.EPSILON) {
6  return Math.abs(a - b) <= epsilon * Math.max(1, Math.abs(a), Math.abs(b));
7}
8
9console.log(nearlyEqual(sum, 0.3));   // true

• Når man tillater feilmarginer i sammenligninger, anbefales en robust implementering som nearlyEqual som også vurderer skalering og bruker absolutte forskjeller.

Kontroll av heltall og sikre heltall (isInteger, isSafeInteger)

Det finnes API-er for å sjekke om en verdi er et heltall og om det er innenfor sikker heltallsgrense.

1// Integer and safe integer checks
2console.log(Number.isInteger(3));                 // true
3console.log(Number.isInteger(3.0));               // true
4console.log(Number.isInteger(3.1));               // false
5
6console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER)); // true
7console.log(Number.isSafeInteger(Number.MAX_SAFE_INTEGER + 1)); // false

• Når nøyaktighet for store heltall er nødvendig, bruk Number.isSafeInteger for å sjekke, og vurder å bruke BigInt for tall som overskrider det området.

Visning og formatering: toFixed, toPrecision, toString

Det finnes metoder for å kontrollere hvordan tall vises. toFixed returnerer en streng med et spesifisert antall desimaler, men vær forsiktig med avrunding.

1// Formatting numbers for display
2const x = 1.23456;
3console.log(x.toFixed(2));         // "1.23"   (string)
4console.log(x.toPrecision(3));     // "1.23"   (string with total significant digits)
5console.log((255).toString(16));   // "ff"     (hexadecimal string)

• toFixed returnerer en streng, så vær oppmerksom på verdier etter at de konverteres til tall for beregninger.

Forsiktighet ved strengsammenføyning og +-operatoren

+-operatoren brukes både for numerisk addisjon og strengsammenføyning, så det kan oppstå utilsiktede resultater avhengig av datatypene som brukes.

1// Pitfall with + operator and type coercion
2console.log(1 + 2 + "px");    // "3px"
3console.log("px" + 1 + 2);    // "px12"
4console.log(1 + "2" - 0);     // 3  (string coerced to number for subtraction)

• Når strenger og tall blandes, er det tryggere å eksplisitt bruke String(), Number() eller malstrenger (template literals) for å unngå implisitt typekonvertering.

Avanserte brukstilfeller: Number.parseInt / Number.parseFloat, valueOf

Number.parseInt og Number.parseFloat er aliaser for de globale funksjonene. valueOf brukes til å hente ut den primitive verdien fra et Number-objekt, men det er sjelden nødvendig i praksis.

1// Number.parseInt/parseFloat aliases and valueOf example
2console.log(Number.parseInt("100", 10));   // 100
3console.log(Number.parseFloat("3.14"));    // 3.14
4
5const nObj = new Number(5);
6console.log(nObj.valueOf());               // 5
7console.log(nObj + 1);                     // 6  (object coerced to primitive)

• Når du bruker Number.parseInt og Number.parseFloat, vær forsiktig med radix og å fjerne mellomrom fra input. Innpakkingsobjekter unngås som regel.

Referanse: Lite hjelpefunksjons-eksempel – Tallsjekk-funksjoner

Her er små hjelpefunksjoner som samler ofte brukte sjekker. Dette gjør oppgaver som inputvalidering enklere.

 1// Small number utility functions
 2function toNumberStrict(value) {
 3  // Return a Number or throw for invalid numeric strings
 4  const n = Number(value);
 5  if (typeof value === "string" && value.trim() === "") {
 6    throw new Error("Empty string is not a valid number");
 7  }
 8  if (Number.isNaN(n)) {
 9    throw new Error(`Invalid number: ${value}`);
10  }
11  return n;
12}
13
14function almostEqual(a, b, eps = Number.EPSILON) {
15  // Robust relative comparison
16  return Math.abs(a - b) <= eps * Math.max(1, Math.abs(a), Math.abs(b));
17}

• Dette er svært allsidige funksjoner som kan brukes gjentatte ganger for inputbehandling og sammenligninger. Implementasjoner som kaster feil er nyttige til valideringsformål.

Oppsummering av ytelse og beste praksis

Følgende er praktiske punkter ved bruk av Number.

• Bruk i hovedsak den primitive typen number og unngå new Number().
• Velg mellom Number() (streng) eller parseInt/parseFloat (delvis uttrekk) for konvertering fra streng til tall, avhengig av brukstilfelle.
• Bruk Number.isNaN og Number.isFinite for sikker kontroll.
• Ved sammenligning av flyttall, bruk Number.EPSILON eller lag en dedikert sammenligningsfunksjon.
• Når heltallsnøyaktighet kreves, bruk Number.isSafeInteger, og hvis rekkevidden overskrides, bruk BigInt.
• Du kan bruke toFixed eller toPrecision for avrunding ved visning, men merk at returverdien er en streng.

Sammendrag

Number er den grunnleggende typen for alle tall i JavaScript, inkludert heltall, desimaler og spesialverdier (NaN og Infinity). Det er viktig å være oppmerksom på typekonvertering og flyttallsfeil, samt å bruke metoder som Number.isNaN og Number.EPSILON riktig. Hvis den sikre heltallsgrensen overskrides, bruk BigInt, og bruk toFixed eller toPrecision for avrunding og visning.

Du kan følge med på artikkelen ovenfor ved å bruke Visual Studio Code på vår YouTube-kanal. Vennligst sjekk ut YouTube-kanalen.

YouTube Video