Typy pierwotne ECMAScript

ECMAScript ma 5 typów pierwotnych (primitive type), tj. Undefined, Null, Boolean, Number i String.

Operator typeof

Operator typeof ma jeden parametr, którym jest zmienna lub wartość do sprawdzenia. Na przykład:

var sTemp = "test string";
alert (typeof sTemp);    // wyjście "string"
alert (typeof 86);    // wyjście "number"

Wywołanie operatora typeof na zmiennej lub wartości zwróci jedną z poniższych wartości:

  • undefined - jeśli zmienna jest typem Undefined
  • boolean - jeśli zmienna jest typem Boolean
  • number - jeśli zmienna jest typem Number
  • string - jeśli zmienna jest typem String
  • object - jeśli zmienna jest typem referencyjnym lub typem Null

Uwaga:Możesz zapytać, dlaczego operator typeof zwraca "Object" dla wartości null. To jest w rzeczywistości błąd w pierwotnej implementacji JavaScript, który został kontynuowany przez ECMAScript. Obecnie null jest uważany za zamiennik obiektu, co wyjaśnia ten konflikt, ale technicznie nadal jest wartością pierwotną.

Typ Undefined

Jak już wspomniano wcześniej, typ Undefined ma tylko jedną wartość, czyli undefined. Gdy zmienna nie jest zainicjalizowana, jej wartość domyślna to undefined.

var oTemp;

Wcześniej wiersz kodu deklaruje zmienną oTemp bez wartości początkowej. Zmienna ta zostanie przypisana wartość undefined, co jest literałem typu undefined. Można użyć poniższego kodu do sprawdzenia, czy wartość tej zmiennej jest równa undefined:

var oTemp;
alert(oTemp == undefined);

Ten kod wyświetli "true", co oznacza, że te dwie wartości są rzeczywiście równe. Można również użyć operatora typeof, aby wyświetlić wartość zmiennej jako undefined:

var oTemp;
alert(typeof oTemp); // wyjście "undefined"

Wskazówka:Wartość undefined różni się od niezdefiniowanej wartości. Jednak operator typeof nie naprawdę odróżnia tych dwóch wartości. Weź pod uwagę poniższy kod:

var oTemp;
alert(typeof oTemp);  // wyjście "undefined"
alert(typeof oTemp2);  // wyjście "undefined"

Powyższy kod wyświetla "undefined" dla obu zmiennych, nawet jeśli tylko zmienna oTemp2 nie została zadeklarowana. Użycie innych operatorów niż typeof w odniesieniu do oTemp2 spowoduje błąd, ponieważ inni operatorzy mogą być używane tylko dla zmiennych, które zostały zadeklarowane.

Na przykład, poniższy kod spowoduje błąd:

var oTemp;
alert(oTemp2 == undefined);

Gdy funkcja nie ma wyraźnie zdefiniowanego zwracanego wartości, zwracana jest wartość "undefined", jak pokazuje poniżej:

function testFunc() {
{}
alert(testFunc() == undefined);  // wyjście "true"

Typ Null

Innym typem, który ma tylko jedną wartość, jest Null, który ma tylko jeden specjalny znak null, to jego literał. Wartość undefined jest pochodną wartości null, więc ECMAScript definiuje je jako równe.

alert(null == undefined);  // wyjście "true"

Choć te dwie wartości są równe, mają różne znaczenie. Wartość undefined jest przypisywana zmiennej, która nie została zainicjalizowana, a wartość null jest używana do reprezentowania braku istniejącego obiektu (o tym został krótko wspomniany przy omawianiu operatora typeof). Jeśli funkcja lub metoda ma zwracać obiekt, to w przypadku braku tego obiektu, zwracany jest zwykle null.

Typ boolean

Typ boolean jest jednym z najczęściej używanych typów w ECMAScript. Ma dwie wartości: true i false (czyli dwa wyrażenia literałowe boolean).

即使 false 不等于 0，0 也可以在必要时被转换成 false，这样在 Boolean 语句中使用两者都是安全的。

var bFound = true;
var bLost = false;

Number 类型

ECMA-262 中定义的最特殊的类型是 Number 类型。这种类型既可以表示 32 位的整数，还可以表示 64 位的浮点数。

直接输入的（而不是从另一个变量访问的）任何数字都被看做 Number 类型的字面量。例如，下面的代码声明了存放整数值的变量，它的值由字面量 86 定义：

var iNum = 86;

八进制数和十六进制数

整数也可以被表示为八进制（以 8 为底）或十六进制（以 16 为底）的字面量。八进制字面量的首数字必须是 0，其后的数字可以是任何八进制数字（0-7），如下面的代码所示：

var iNum = 070;  //070 等于十进制的 56

要创建十六进制的字面量，首位数字必须为 0，后面接字母 x，然后是任意的十六进制数字（0 到 9 和 A 到 F）。这些字母可以是大写的，也可以是小写的。例如：

var iNum = 0x1f;  //0x1f 等于十进制的 31
var iNum = 0xAB;  //0xAB 等于十进制的 171

Wskazówka:尽管所有整数都可以表示为八进制或十六进制的字面量，但所有数学运算返回的都是十进制结果。

浮点数

要定义浮点值，必须包括小数点和小数点后的一位数字（例如，用 1.0 而不是 1）。这被看作浮点数字面量。例如：

var fNum = 5.0;

对于浮点字面量的有趣之处在于，用它进行计算前，真正存储的是字符串。

科学计数法

对于非常大或非常小的数，可以用科学计数法表示浮点数，可以把一个数表示为数字（包括十进制数字）加 e（或 E），后面加乘以 10 的倍数。例如：

var fNum = 5.618e7

该符号表示的是数 56180000。把科学计数法转化成计算式就可以得到该值：5.618 x 107。

也可以用科学计数法表示非常小的数，例如 0.00000000000000008 可以表示为 8-e17(Tutaj, 10 jest podniesiony do -17 potęgi, co oznacza, że musi być podzielone przez 10 17 razy). ECMAScript domyślnie konwertuje liczby zmiennoprzecinkowe z 6 lub więcej wiodącymi zerami na format liczby naukowej.

Wskazówka:Również wartości zmiennoprzecinkowe mogą być przechowywane w formacie 64-bitowym IEEE 754, co oznacza, że wartości dziesiętne mogą mieć maksymalnie 17 miejsc po przecinku. Wartości po 17 miejscach po przecinku są cięte, co może powodować małe błędy matematyczne.

Specjalne wartości Number

Kilka specjalnych wartości jest zdefiniowanych jako typ Number. Pierwsze dwa to Number.MAX_VALUE i Number.MIN_VALUE, które definiują zewnętrzne granice zbioru wartości Number. Wszystkie liczby ECMAScript muszą się mieścić między tymi dwoma wartościami. Jednak wyniki obliczeń mogą nie leżeć między tymi wartościami.

Gdy wynik obliczeń jest większy niż Number.MAX_VALUE, jest przypisywana wartość Number.POSITIVE_INFINITY, co oznacza, że nie ma już wartości liczbowych. Podobnie, obliczenia wynoszące wartość mniejszą niż Number.MIN_VALUE będą przypisywać wartość Number.NEGATIVE_INFINITY, co również oznacza, że nie ma już wartości liczbowych. Jeśli obliczenia zwracają wartość nieskończoną, wynik nie może być użyty w innych obliczeniach.

Rzeczywiście, są specjalne wartości oznaczające nieskończoność (jak można się domyślić), czyli Infinity. Wartość Number.POSITIVE_INFINITY to Infinity. Wartość Number.NEGATIVE_INFINITY to -Infinity.

Ponieważ nieskończoność może być zarówno liczbą dodatnią, jak i ujemną, można użyć metody, aby sprawdzić, czy liczba jest skończona (zamiast单独测试每个无穷数). Można wywołać metodę isFinite() dla każdej liczby, aby upewnić się, że liczba nie jest nieskończona. Na przykład:

var iResult = iNum * some_really_large_number;
if (isFinite(iResult)) {
    alert("finite");
{}
else {
    alert("infinite");
{}

Ostatnim specjalnym wartością jest NaN, co oznacza 'Nie liczba' (Not a Number). NaN to dziwna specjalna wartość. Ogólnie rzecz biorąc, taka sytuacja występuje podczas nieudanej konwersji typów (String, Boolean itp.). Na przykład, konwersja słowa 'blue' na liczbę będzie się nie powiodła, ponieważ nie ma odpowiedniego wartości liczbowej. Jak nieskończoność, NaN nie może być użyty w obliczeniach arytmetycznych. Jedną z dziwnych cech NaN jest to, że nie jest równa sobie, co oznacza, że poniższy kod zwróci fałsz:

alert(NaN == NaN);  //wyświetla "false"

Z tego powodu nie zaleca się używania wartości NaN. Funkcja isNaN() działa całkiem dobrze:

alert(isNaN("blue"));  //wyświetla "true"
alert(isNaN("666"));  //wyświetla "false"

Typ String

Unikalność typu String polega na tym, że jest to jedyny typ prymitywny, który nie ma stałego rozmiaru. Można w nim przechowywać 0 lub więcej znaków Unicode (Unicode to międzynarodowy zestaw znaków, który zostanie omówiony w tym kursie).

Każdy znak w stringu ma określone położenie, zaczynając od 0 dla pierwszego znaku, 1 dla drugiego znaku itd. Oznacza to, że położenie ostatniego znaku w stringu jest równe długości stringa minus 1:

Długość ciągów znaków i pozycja znaków

Literał stringowy jest deklarowany za pomocą podwójnych cudzysłów (""), lub pojedynczych cudzysłów (''). W Javie stringi są deklarowane za pomocą podwójnych cudzysłów, a znaki za pomocą pojedynczych cudzysłów. Jednakże, ponieważ ECMAScript nie ma typu znaku, można używać któregokolwiek z tych zapisów. Na przykład, oba poniższe wiersze kodu są poprawne:

var sColor1 = "red";
var sColor2 = 'red';

Typ String zawiera również kilka rodzajów literałów, deweloperzy Java, C i Perl powinni być z tym dobrze zaznajomieni.

Poniżej znajdują się znaki literałowe ECMAScript:

literate znaczenie
\n znak nowej linii
\t tabulator
\b spacja
\r enter
\f znak nowej strony
\\\ odwrócony znak ukośny
\' jeden cudzysłów
\" dwoje cudzysłów
\0nnn kod ósemkowy nnn oznaczający znak (n to liczba ósemkowa z zakresu 0 do 7 (ósemkowy)
\xnn kod szesnastkowy nn oznaczający znak (n To liczba szesnastkowa z zakresu 0 do F (heksadecymalna)
\unnnn kod szesnastkowy nnnn oznaczający znak Unicode (n To liczba szesnastkowa z zakresu 0 do F (heksadecymalna)