JavaScriptová čísla
JavaScript má pouze jeden typ čísla. Čísla lze psát s desetinnými místy nebo bez nich.
Příklad
let x = 3.14; // A number with decimals
let y = 3; // A number without decimals
Extra velká nebo extra malá čísla lze zapsat pomocí vědeckého (exponentního) zápisu:
Příklad
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
Čísla JavaScriptu jsou vždy 64bitové s pohyblivou řádovou čárkou
Na rozdíl od mnoha jiných programovacích jazyků JavaScript nedefinuje různé typy čísel, jako jsou celá čísla, krátká, dlouhá, s plovoucí desetinnou čárkou atd.
Čísla JavaScript jsou vždy uložena jako čísla s pohyblivou řádovou čárkou s dvojitou přesností podle mezinárodního standardu IEEE 754.
Tento formát ukládá čísla v 64 bitech, kde číslo (zlomek) je uloženo v bitech 0 až 51, exponent v bitech 52 až 62 a znaménko v bitu 63:
| Hodnota (také znám jako zlomek/mantisa) | Exponent | Podepsat |
|---|---|---|
| 52 bitů (0–51) | 11 bitů (52–62) | 1 bit (63) |
Přesnost celého čísla
Celá čísla (čísla bez tečky nebo exponentu) jsou přesná až na 15 číslic.
Příklad
let x = 999999999999999; // x will be 999999999999999
let y = 9999999999999999; // y will be 10000000000000000
Maximální počet desetinných míst je 17.
Plovoucí přesnost
Aritmetika s plovoucí desetinnou čárkou není vždy 100% přesná:
let x = 0.2 + 0.1;
K vyřešení výše uvedeného problému pomáhá násobení a dělení:
let x = (0.2 * 10 + 0.1 * 10) / 10;
Přidávání čísel a řetězců
VAROVÁNÍ !!
JavaScript používá operátor + pro sčítání i zřetězení.
Čísla se přidávají. Řetězce jsou zřetězeny.
Pokud sečtete dvě čísla, výsledkem bude číslo:
Příklad
let x = 10;
let y = 20;
let z = x + y;
Pokud přidáte dva řetězce, výsledkem bude zřetězení řetězců:
Příklad
let x = "10";
let y = "20";
let z = x + y;
Pokud přidáte číslo a řetězec, výsledkem bude zřetězení řetězce:
Příklad
let x = 10;
let y = "20";
let z = x + y;
Pokud přidáte řetězec a číslo, výsledkem bude zřetězení řetězce:
Příklad
let x = "10";
let y = 20;
let z = x + y;
Častou chybou je očekávat, že tento výsledek bude 30:
Příklad
let x = 10;
let y = 20;
let z = "The result is: " + x + y;
Častou chybou je očekávat, že tento výsledek bude 102030:
Příklad
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
Interpret JavaScriptu pracuje zleva doprava.
Prvních 10 + 20 se sečte, protože x a y jsou obě čísla.
Potom se 30 + "30" zřetězí, protože z je řetězec.
Numerické řetězce
Řetězce JavaScriptu mohou mít číselný obsah:
let x = 100; // x is a number
let y = "100"; // y is a
string
JavaScript se pokusí převést řetězce na čísla ve všech numerických operacích:
Toto bude fungovat:
let x = "100";
let y = "10";
let z = x / y;
Toto bude také fungovat:
let x = "100";
let y = "10";
let z = x * y;
A bude fungovat toto:
let x = "100";
let y = "10";
let z = x - y;
Ale to nebude fungovat:
let x = "100";
let y = "10";
let z = x + y;
V posledním příkladu JavaScript používá ke zřetězení řetězců operátor +.
NaN - Není číslo
NaN je vyhrazené slovo JavaScriptu označující, že číslo není zákonným číslem.
Pokus o aritmetiku s nečíselným řetězcem bude mít za následek NaN(není číslo):
Příklad
let x = 100 / "Apple";
Pokud však řetězec obsahuje číselnou hodnotu , výsledkem bude číslo:
Příklad
let x = 100 / "10";
isNaN()
Chcete- li zjistit, zda hodnota není číslo, můžete použít globální funkci JavaScript :
Příklad
let x = 100 / "Apple";
isNaN(x);
Pozor na NaN. Pokud použijete NaNv matematické operaci, výsledek bude také NaN:
Příklad
let x = NaN;
let y = 5;
let z = x + y;
Nebo výsledkem může být zřetězení jako NaN5:
Příklad
let x = NaN;
let y = "5";
let z = x + y;
NaNje číslo: typeof NaNvrací number:
Příklad
typeof NaN;
Nekonečno
Infinity(nebo -Infinity) je hodnota, kterou JavaScript vrátí, pokud vypočítáte číslo mimo největší možné číslo.
Příklad
let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
}
Dělení 0 (nulou) také generuje Infinity:
Příklad
let x = 2 / 0;
let y = -2 / 0;
Infinityje číslo: typeof Infinityvrací number.
Příklad
typeof Infinity;
Hexadecimální
JavaScript interpretuje číselné konstanty jako hexadecimální, pokud jim předchází 0x.
Příklad
let x = 0xFF;
Nikdy nepište číslo s úvodní nulou (např. 07).
Některé verze JavaScriptu interpretují čísla jako osmičkové, pokud jsou napsány s nulou na začátku.
Ve výchozím nastavení JavaScript zobrazuje čísla jako základní 10 desetinných míst.
Ale můžete použít toString()metodu pro výstup čísel od základu 2
do základu 36 .
Hexadecimální číslo je základ 16 . Desetinné číslo je základ 10 . Osmičková je základna 8 . Binární je základ 2 .
Příklad
let myNumber = 32;
myNumber.toString(10);
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(8);
myNumber.toString(2);
JavaScriptová čísla jako objekty
Normálně jsou čísla JavaScriptu primitivní hodnoty vytvořené z literálů:
let x = 123;
Čísla však mohou být také definována jako objekty s klíčovým slovem new:
let y = new Number(123);
Příklad
let x = 123;
let y = new Number(123);
Nevytvářejte objekty Number.
Klíčové newslovo komplikuje kód a zpomaluje rychlost provádění.
Objekty čísel mohou způsobit neočekávané výsledky:
Při použití ==operátoru se x a y rovnají :
let x = 500;
let y = new Number(500);
Při použití ===operátoru se x a y nerovnají .
let x = 500;
let y = new Number(500);
Všimněte si rozdílu mezi (x==y)a (x===y).
(x == y)pravda nebo lež?
let x = new Number(500);
let y = new Number(500);
(x === y)pravda nebo lež?
let x = new Number(500);
let y = new Number(500);
Comparing two JavaScript objects always returns false.
Complete JavaScript Number Reference
For a complete Number reference, visit our:
Complete JavaScript Number Reference.
The reference contains descriptions and examples of all Number properties and methods.