`Number`-klassen i JavaScript

Den här artikeln förklarar Number-klassen i JavaScript.

Vi kommer att noggrant förklara egenskaperna hos Number, vanliga fallgropar, användbara API:er och praktiska exempel steg för steg.

YouTube Video

Number-klassen i JavaScript

Number är den grundläggande numeriska typen i JavaScript och representeras som en IEEE-754 dubbelprecision flyttal (64-bitars).

Grunder: Numreringsrepresentation och typkontroll

I JavaScript representeras alla nummer som den primitiva 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)

• Den här koden visar skillnaden mellan en primitiv number och Number-wrapperobjektet. Vanligtvis används primitiva typer istället för omslagsobjekt.

Särskilda värden: NaN, Infinity och konstanter

Number tillhandahåller särskilda värden (NaN, Infinity) och 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

• Heltal större än eller lika med MAX_SAFE_INTEGER kan inte representeras exakt. Överväg att använda BigInt om exakthet krävs. EPSILON används för jämförelser av flyttal.

Konvertering till nummer: Number(), parseInt, parseFloat och +-operatorn

Det finns flera sätt att konvertera en sträng till ett nummer, var och en med olika beteenden.

 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() returnerar NaN om inte hela strängen är strikt i numeriskt format, medan parseInt och parseFloat tolkar den numeriska delen från början av strängen. Det är säkrare att alltid uttryckligen specificera basen (radix) när du använder parseInt.

Hantering och kontroll av NaN: isNaN och Number.isNaN

NaN (Not-A-Number) är speciell eftersom NaN !== NaN. Det finns skillnader i hur de kontrollerar; globala isNaN utför typkonvertering och kan ge falska positiva, så Number.isNaN rekommenderas.

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

• Använd Number.isNaN för att kontrollera tal och validera beräkningsresultat för att undvika onödig typkonvertering.

Fel vid flyttalsberäkningar och jämförelser med Number.EPSILON

På grund av IEEE-754 uppstår fel som 0.1 + 0.2 !== 0.3. För noggranna jämförelser är det vanligt att använda skillnaden och 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 fel tolereras vid jämförelse rekommenderas en robust implementation som nearlyEqual som även hanterar skalning och absoluta skillnader.

Kontrollera heltal och säkra heltal (isInteger, isSafeInteger)

Det finns API:er för att kontrollera om ett värde är ett heltal och om det ligger inom det säkra heltalsintervallet.

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 exakthet för stora heltal krävs, använd Number.isSafeInteger för att kontrollera och överväg att använda BigInt för nummer som överskrider det intervallet.

Visning och formatering: toFixed, toPrecision, toString

Det finns metoder för att kontrollera visningen av nummer. toFixed returnerar en sträng med ett angivet antal decimaler, men var försiktig med avrundning.

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 returnerar en sträng, så var uppmärksam på värdena efter konvertering till tal för beräkningar.

Varningar om strängkonkatenering och +-operatorn

+-operatorn används för både numerisk addition och strängkonkatenering, så oavsiktliga resultat kan uppstå beroende på vilka datatyper som är inblandade.

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 strängar och tal blandas är det säkrare att uttryckligen använda String(), Number() eller mall-litteraler för att undvika implicit typkonvertering.

Avancerade användningsfall: Number.parseInt / Number.parseFloat, valueOf

Number.parseInt och Number.parseFloat är alias för de globala funktionerna. valueOf används för att hämta det primitiva värdet från ett Number-objekt, men det behövs sällan i praktiken.

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)

• Var försiktig med basen (radix) och att trimma indata när du använder Number.parseInt och Number.parseFloat. Omslagsobjekt undviks vanligtvis.

Referens: Litet verktygsexempel - valideringsfunktioner för nummer

Här finns små hjälpfunktioner som samlar vanliga kontroller. Detta gör uppgifter som inmatningsvalidering enklare.

 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}

• Detta är mycket mångsidiga funktioner som kan återanvändas för inmatningshantering och jämförelser. Implementationer som kastar fel är användbara för valideringsändamål.

Sammanfattning av prestanda och bästa praxis

Följande är praktiska punkter vid användning av Number.

• Använd i grunden typen number och undvik new Number().
• Välj mellan Number() (strikt) eller parseInt/parseFloat (partiell extraktion) för omvandling från sträng till nummer beroende på användningsfallet.
• Använd Number.isNaN och Number.isFinite för säker kontroll.
• För jämförelser av flyttal, använd Number.EPSILON eller skapa en särskild jämförelsefunktion.
• När heltalsexakthet krävs, använd Number.isSafeInteger, och om det överstiger intervallet, använd BigInt.
• Du kan använda toFixed eller toPrecision för avrundning vid visning, men observera att returvärdet är en sträng.

Sammanfattning

Number är basstypen för alla nummer i JavaScript, inklusive heltal, decimaltal och speciella värden (NaN och Infinity). Det är viktigt att vara medveten om typkonvertering och flyttalsfel samt att använda metoder som Number.isNaN och Number.EPSILON korrekt. Om det säkra heltalsintervallet överskrids, använd BigInt, och använd toFixed eller toPrecision för avrundning och visning.

Du kan följa med i artikeln ovan med hjälp av Visual Studio Code på vår YouTube-kanal. Vänligen kolla även in YouTube-kanalen.

YouTube Video