Számok ebben a kurzusban:

A(z) Számok fogalomról

A JavaScriptben két különböző fajta szám létezik: a number és a bigint.

A number a leggyakrabban használt, és a numerikus adattípust a kétszeres pontosságú, 64 bites lebegőpontos formátumban ábrázolja.

• number: numerikus adattípus kétszeres pontosságú, 64 bites lebegőpontos formátumban (IEEE 754). Példák: -6, -2.4, 0, 0.1, 1, 3.14, 16.984025, 25, 976, 1024.0 és 500000.
• bigint: numerikus adattípus, amely egész számokat képes ábrázolni tetszőleges pontosságú formátumban. Példák: -12n, 0n, 4n és 9007199254740991n.

let numericValue = 42;
// => 42

Egy olyan számliterál, mint a 42, a JavaScript-kódban lebegőpontos érték, nem egész szám. A mindennapi használatban nincs külön egész szám típus. A bigint típust nem arra tervezték, hogy a mindennapi használatban felváltsa a number típust. A 42 továbbra is Number, nem BigInt.

A számok literál formában is kifejezhetők, például 0b101, 0o13, 0x0A. A numerikus lexikai nyelvtanról itt olvashatsz többet.

Különleges jelölések

Exponenciális jelölés

Az E-jelölés olyan számot jelöl, amelyet meg kell szorozni 10 adott hatványával. Az E-jelölés formátuma: egy szám, utána e vagy E, majd a 10 hatványa, amivel szorozni kell.

const num = 3.125e7;
// => 31250000
// The notation essentially says, "Take 3.125 and multiply it by 10^7".

Az E-jelölés nagyon kis számok ábrázolására is használható:

const num = 325987e-6; // Equals 0.325987
// The notation essentially says, "Take 325987 and multiply it by 10^-6.

Alulvonásos jelölés

Az alulvonásokkal olvashatóbbá teheted a nagy számokat. A fordító teljesen figyelmen kívül hagyja az alulvonásokat.

const num = 1_000_000; // You can read this as 1,000,000
console.log(num);
// => 1000000

Beépített objektum

Két beépített objektum hasznos, amikor számokkal foglalkozunk:

• Number: statikus tulajdonságok gyakori / hasznos értékekhez, statikus metódusok típusellenőrzéshez és típuskonverzióhoz, példánymetódusok típuskonverzióhoz és számok stringgé formázásához.
• Math: tulajdonságok és metódusok matematikai állandókhoz és függvényekhez; nem működik BigInt értékekkel.

A Math metódusokat tartalmaz a számok kerekítéséhez is. A rendelkezésre álló kerekítési lehetőségekről ebben a javascript.info kerekítésről szóló cikkében olvashatsz többet.

Math.floor(234.34); // => 234
Math.ceil(234.34); // => 235

A beépített globális Number object egyben egy globális function is, amellyel szinte bármi szám-szerű dolog number típusúvá alakítható. Ez kevésbé megengedő, mint egy string-et számmá parse-olni.

const date = new Date('December 17, 1995 03:24:00');
const unix = Number(date);

unix;
// => 819199440000

A JavaScriptben a számoknak háromféle maximum- (és minimum- / maximális negatív) értéke van:

• VALUE: a Number.MAX_VALUE és a Number.MIN_VALUE adja
• INFINITY: a Number.POSITIVE_INFINITY és a Number.NEGATIVE_INFINITY adja
• SAFE_INTEGER: a Number.MAX_SAFE_INTEGER és a Number.MIN_SAFE_INTEGER adja

Mivel a JavaScriptben a számok implementációja ilyen, nem ábrázolható minden szám a Number.MIN_VALUE és a Number.MAX_VALUE között. Ugyanakkor a Number.MIN_SAFE_INTEGER - 1 és a Number.MAX_SAFE_INTEGER + 1 közötti minden szám ábrázolható.

Különleges számértékek

A JavaScriptben több különleges számérték is van:

• Két hibaérték: NaN és Infinity.
• Két nullaérték: +0 és -0.

NaN, azaz „nem szám”

A NaN hibaérték (más néven „nem szám”) a következő esetekben keletkezik.

• Egy számot nem sikerült parse-olni:

  Number('123'); // => 123
  Number('Hello, World!'); // => NaN
  

• Egy művelet meghiúsult:

  Math.sqrt(-64); // => NaN
  

• Az egyik operandus NaN:

  NaN + 69; // => NaN
  

A NaN az egyetlen érték, amely nem egyenlő önmagával:

NaN === NaN; // => false

Ha ellenőrizni szeretnéd, hogy egy érték NaN-e, a globális isNaN() függvényt kell használnod:

isNaN(NaN); // => true
isNaN(123); // => false

Infinity

Az Infinity hibaérték két probléma egyikére utal:

• Egy szám nem ábrázolható, mert túl nagy a nagyságrendje.

  Math.pow(2, 1024); // => Infinity
  

• Nullával való osztás történt.

  6 / 0; // => Infinity
  -6 / 0; // => -Infinity
  

Az Infinity nagyobb bármely más számnál (a NaN kivételével). Hasonlóképpen a -Infinity kisebb bármely más számnál (a NaN kivételével).

A globális isFinite() függvénnyel ellenőrizheted, hogy egy érték valódi szám-e (se nem végtelen, se nem NaN):

isFinite(80085); // => true
isFinite(Infinity); // => false
isFinite(NaN); // => false

A két nulla

A +0 és a -0 különböző számok a JavaScriptben. Akkor keletkezhetnek, ha olyan számot ábrázoltál, amely olyan kicsi, hogy megkülönböztethetetlen a 0-tól. Az előjeles nulla lehetővé teszi, hogy rögzítsd, „melyik irányból” közelítetted meg a nullát; vagyis hogy milyen előjele volt a számnak, mielőtt nullának tekintették. A legjobb gyakorlat úgy tenni, mintha csak egy nulla létezne.

Összehasonlítás

Két szám akkor számít egyenlőnek, ha ugyanaz az értékük.

1 == 1.0;
// => true

1 === 1.0;
// => true
// Remember, all numbers are floating-points, so this is
// different syntax for the exact same value.

1 === 1n;
// => false
// Strictly checking a number against a bigint will always result
// in false.

Az összehasonlításról általában, valamint a numerikus értékek JavaScriptbeli összehasonlításáról az Összehasonlítás oldalon olvashatsz többet.

Buktatók

Mivel a JavaScriptben a számok lebegőpontos számok, a velük végzett minden matematika lebegőpontos matematika. Ezért a JavaScriptben:

0.1 + 0.2 === 0.3;
// => false

Rövid magyarázatért lásd a 0.30000000000000004.com oldalt, részletes magyarázatért pedig az Oracle Numerical Computation Guide „What Every Computer Scientist Should Know About Floating-Point Arithmetic” című művének Appendix D függelékét.