Liczby JavaScript
JavaScript ma tylko jeden typ liczby. Liczby mogą być zapisywane z lub bez miejsc dziesiętnych.
Przykład
let x = 3.14; // A number with decimals
let y = 3; // A number without decimals
Liczby bardzo duże lub bardzo małe można zapisać w notacji naukowej (wykładniczej):
Przykład
let x = 123e5; // 12300000
let y = 123e-5; // 0.00123
Liczby JavaScript są zawsze 64-bitowe zmiennoprzecinkowe
W przeciwieństwie do wielu innych języków programowania, JavaScript nie definiuje różnych typów liczb, takich jak liczby całkowite, krótkie, długie, zmiennoprzecinkowe itp.
Liczby JavaScript są zawsze przechowywane jako liczby zmiennoprzecinkowe podwójnej precyzji, zgodnie z międzynarodowym standardem IEEE 754.
Ten format przechowuje liczby w 64 bitach, gdzie liczba (ułamek) jest przechowywana w bitach od 0 do 51, wykładnik w bitach 52 do 62, a znak w bicie 63:
| Wartość (aka Frakcja/Mantysa) | Wykładnik potęgowy | Podpisać |
|---|---|---|
| 52 bity (0 - 51) | 11 bitów (52 - 62) | 1 bit (63) |
Dokładność liczb całkowitych
Liczby całkowite (liczby bez kropki lub notacji wykładniczej) mają dokładność do 15 cyfr.
Przykład
let x = 999999999999999; // x will be 999999999999999
let y = 9999999999999999; // y will be 10000000000000000
Maksymalna liczba miejsc po przecinku to 17.
Pływająca precyzja
Arytmetyka zmiennoprzecinkowa nie zawsze jest w 100% dokładna:
let x = 0.2 + 0.1;
Aby rozwiązać powyższy problem, warto mnożyć i dzielić:
let x = (0.2 * 10 + 0.1 * 10) / 10;
Dodawanie liczb i ciągów
OSTRZEŻENIE !!
JavaScript używa operatora + zarówno do dodawania, jak i łączenia.
Numery są dodawane. Ciągi są łączone.
Jeśli dodasz dwie liczby, wynikiem będzie liczba:
Przykład
let x = 10;
let y = 20;
let z = x + y;
Jeśli dodasz dwa ciągi, wynikiem będzie konkatenacja ciągów:
Przykład
let x = "10";
let y = "20";
let z = x + y;
Jeśli dodasz liczbę i ciąg, wynikiem będzie konkatenacja ciągu:
Przykład
let x = 10;
let y = "20";
let z = x + y;
Jeśli dodasz ciąg i liczbę, wynikiem będzie konkatenacja ciągu:
Przykład
let x = "10";
let y = 20;
let z = x + y;
Częstym błędem jest oczekiwanie, że wynik ten wyniesie 30:
Przykład
let x = 10;
let y = 20;
let z = "The result is: " + x + y;
Częstym błędem jest oczekiwanie, że ten wynik będzie 102030:
Przykład
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
Interpreter JavaScript działa od lewej do prawej.
Pierwsze 10 + 20 jest dodawane, ponieważ x i y są liczbami.
Następnie łączy się 30 + „30”, ponieważ z jest łańcuchem.
Ciągi numeryczne
Ciągi JavaScript mogą mieć zawartość liczbową:
let x = 100; // x is a number
let y = "100"; // y is a
string
JavaScript będzie próbował konwertować łańcuchy na liczby we wszystkich operacjach numerycznych:
To zadziała:
let x = "100";
let y = "10";
let z = x / y;
To również zadziała:
let x = "100";
let y = "10";
let z = x * y;
I to zadziała:
let x = "100";
let y = "10";
let z = x - y;
Ale to nie zadziała:
let x = "100";
let y = "10";
let z = x + y;
W ostatnim przykładzie JavaScript używa operatora + do łączenia ciągów.
NaN – To nie jest liczba
NaN jest słowem zastrzeżonym JavaScript wskazującym, że liczba nie jest liczbą legalną.
Próba wykonania arytmetyki z ciągiem nienumerycznym da wynik NaN(Not a Number):
Przykład
let x = 100 / "Apple";
Jeśli jednak ciąg zawiera wartość liczbową , wynikiem będzie liczba:
Przykład
let x = 100 / "10";
Możesz użyć globalnej funkcji JavaScript, isNaN()
aby dowiedzieć się, czy wartość nie jest liczbą:
Przykład
let x = 100 / "Apple";
isNaN(x);
Uważaj na NaN. Jeśli użyjesz NaNw operacji matematycznej, wynikiem będzie również NaN:
Przykład
let x = NaN;
let y = 5;
let z = x + y;
Lub wynikiem może być konkatenacja, taka jak NaN5:
Przykład
let x = NaN;
let y = "5";
let z = x + y;
NaNto liczba: typeof NaNzwraca number:
Przykład
typeof NaN;
nieskończoność
Infinity(lub -Infinity) to wartość zwrócona przez JavaScript, jeśli obliczysz liczbę poza największą możliwą liczbą.
Przykład
let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
myNumber = myNumber * myNumber;
}
Dzielenie przez 0 (zero) generuje również Infinity:
Przykład
let x = 2 / 0;
let y = -2 / 0;
Infinityto liczba: typeof Infinityzwraca number.
Przykład
typeof Infinity;
Szesnastkowy
JavaScript interpretuje stałe numeryczne jako szesnastkowe, jeśli są poprzedzone 0x.
Przykład
let x = 0xFF;
Nigdy nie pisz liczby z wiodącym zerem (np. 07).
Niektóre wersje JavaScriptu interpretują liczby jako ósemkowe, jeśli są napisane z wiodącym zerem.
Domyślnie JavaScript wyświetla liczby jako 10 miejsc po przecinku.
Ale możesz użyć tej toString()metody, aby wyprowadzić liczby od podstawy 2
do podstawy 36 .
Szesnastkowy ma podstawę 16 . Dziesiętny to podstawa 10 . Ósemka to podstawa 8 . Binarny to baza 2 .
Przykład
let myNumber = 32;
myNumber.toString(10);
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(8);
myNumber.toString(2);
Liczby JavaScript jako obiekty
Normalnie liczby JavaScript są prymitywnymi wartościami utworzonymi z literałów:
let x = 123;
Ale liczby można również zdefiniować jako obiekty za pomocą słowa kluczowego new:
let y = new Number(123);
Przykład
let x = 123;
let y = new Number(123);
Nie twórz obiektów Number.
Słowo newkluczowe komplikuje kod i spowalnia szybkość wykonywania.
Liczba obiektów może dawać nieoczekiwane wyniki:
Używając ==operatora, x i y są równe :
let x = 500;
let y = new Number(500);
Używając ===operatora, x i y nie są równe .
let x = 500;
let y = new Number(500);
Zwróć uwagę na różnicę między (x==y)a (x===y).
(x == y) prawda czy fałsz?
let x = new Number(500);
let y = new Number(500);
(x === y) prawda czy fałsz?
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.