ECMAScript Primære Typer

ECMAScript har 5 primitivtyper (primitive type), nemlig Undefined, Null, Boolean, Number og String.

typeof-operatoren

typeof-operatoren har en parameter, nemlig den variabel eller værdi, der skal kontrolleres. For eksempel:

var sTemp = "test string";
alert (typeof sTemp);    //Udskriver "string"
alert (typeof 86);    //Udskriver "number"

Når typeof-operatoren kaldes på en variabel eller værdi, returneres en af følgende værdier:

  • undefined - hvis variablen er Undefined-type
  • boolean - hvis variablen er Boolean-type
  • number - hvis variablen er Number-type
  • string - hvis variablen er String-type
  • object - hvis variablen er en referencetype eller Null-type

Kommentar:Du kan måske spørge, hvorfor typeof-operatoren returnerer "Object" for null-værdier. Dette er faktisk en fejl i JavaScripts oprindelige implementering, som ECMAScript har videreført. Nu betragtes null som en placeholder for objekter, hvilket forklarer denne modstridelse, men teknisk set er det stadig en primitiv værdi.

Undefined-type

Som nævnt tidligere har undefined-type kun én værdi, nemlig undefined. Når en variabel ikke er initialiseret, er dens standardværdi undefined.

var oTemp;

Det foregående kode stykke deklarerer variablen oTemp uden en værdi. Denne variabel vil få værdien undefined, dvs. en undefined-litteral. Man kan teste om værdien af denne variabel er undefined med følgende kode segment:

var oTemp;
alert(oTemp == undefined);

Dette kode stykke viser "true", hvilket viser, at disse to værdier faktisk er ens. Man kan også bruge typeof-operatoren til at vise, at en variabels værdi er undefined:

var oTemp;
alert(typeof oTemp); // Uddatter "undefined"

Tip:Værdien undefined er ikke den samme som en udefineret værdi. Men typeof-operatoren adskiller ikke virkelig disse to værdier. Overvej følgende kode:

var oTemp;
alert(typeof oTemp);  // Uddatter "undefined"
alert(typeof oTemp2);  // Uddatter "undefined"

Denne kode uddatter "undefined" for begge variabler, selvom kun variabelen oTemp2 ikke er deklareret. Hvis man bruger en operator anden end typeof til oTemp2, vil det forårsage en fejl, fordi andre operatører kun kan bruges på deklarerede variabler.

For eksempel vil følgende kode forårsage en fejl:

var oTemp;
alert(oTemp2 == undefined);

Når en funktion ikke har en specifik returværdi, returneres også værdien "undefined", som vist nedenfor:

function testFunc() {
{}
alert(testFunc() == undefined);  // Uddatter "true"

Null-type

En anden type med kun én værdi er Null, som kun har én specifik værdi: null, dvs. dens litteral. Værdien undefined er faktisk afledt af værdien null, og derfor definerer ECMAScript dem som ens.

alert(null == undefined);  // Uddatter "true"

Selvom disse to værdier er ens, har de forskellige betydninger. undefined er værdien, der tildelt en variabel, der ikke er initialiseret, og null bruges til at repræsentere et objekt, der ikke eksisterer (dette blev kort introduceret, når typeof-operatoren blev diskuteret). Hvis en funktion eller metode skal returnere et objekt, og objektet ikke findes, returneres typisk null.

Boolean-type

Boolean-typen er en af de mest almindelige typer i ECMAScript. Den har to værdier: true og false (dvs. to Boolean-litteraler).

即使 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

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

浮点数

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

var fNum = 5.0;

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

科学计数法

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

var fNum = 5.618e7

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

也可以用科学计数法表示非常小的数，例如 0.00000000000000008 可以表示为 8-e17(Her er 10 blevet hævet til -17. potens, hvilket betyder, at det skal divides med 10 17 gange). ECMAScript konverterer som standard flyttalsnumre med 6 eller flere førende 0'er til videnskabelig notation.

Tip:Man kan også gemme flyttalsværdier i 64-bit IEEE 754-format, hvilket betyder, at decimalværdierne maksimalt kan have 17 decimalpladser. Værdier efter 17 pladser vil blive skåret væk, hvilket kan forårsage små matematiske fejl.

Specielle Number-værdier

Nogle specielle værdier er også defineret som Number-type. De første to er Number.MAX_VALUE og Number.MIN_VALUE, som definerer de ydre grænser for Number-værdisætget. Alle ECMAScript-tal skal være mellem disse to værdier. Dog kan beregningsresultaterne ikke nødvendigvis falde mellem disse to værdier.

Når et beregningsresultat er større end Number.MAX_VALUE, tildelinges det værdien Number.POSITIVE_INFINITY, hvilket betyder, at der ikke længere er nogen numerisk værdi. På samme måde vil beregninger, der genererer et tal mindre end Number.MIN_VALUE, tildelinges værdien Number.NEGATIVE_INFINITY, hvilket også betyder, at der ikke længere er nogen numerisk værdi. Hvis beregningen returnerer en uendelig værdi, kan det genererede resultat ikke bruges i andre beregninger.

Faktisk findes der specifikke værdier, der repræsenterer uendelige tal, (som du måske har gættet) nemlig Infinity. Number.POSITIVE_INFINITY's værdi er Infinity. Number.NEGATIVE_INFINITY's værdi er -Infinity.

Såvel som uendelige tal kan være positive som negative, kan man bruge en metode til at afgøre, om et tal er finit (i stedet for at teste hver uendelige værdi). Man kan kalde isFinite() metoden for ethvert tal for at sikre, at det ikke er uendeligt. For eksempel:

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

Den sidste specielle værdi er NaN, som betyder 'ikke et tal' (Not a Number). NaN er en mærkelig specielle værdi. Generelt set opstår dette problem, når en konvertering fra type (String, Boolean osv.) fejler. For eksempel vil det mislykkes at konvertere ordet 'blue' til et tal, fordi der ikke findes et tilsvarende numerisk værdi. Som med uendelig, kan NaN ikke bruges i aritmetiske beregninger. En anden mærkelig egenskab ved NaN er, at den ikke er lig med sig selv, hvilket betyder, at følgende kode vil returnere false:

alert(NaN == NaN);  //Uddatter "false"

Af denne grund anbefales det ikke at bruge NaN-værdien selv. Funktionen isNaN() gør det ret godt:

alert(isNaN("blue"));  //Uddatter "true"
alert(isNaN("666"));  //Uddatter "false"

String-type

Det unikke ved String-typen er, at det er den eneste primitive type, der ikke har en fast størrelse. Man kan gemme 0 eller flere Unicode-tegn i en streng, repræsenteret ved 16-bit heltal (Unicode er en international tegnkæde, som dette kursus vil diskutere senere).

Hver karakter i en streng har en bestemt position, hvor den første karakter starter ved position 0, den næste karakter ved position 1, og så videre. Dette betyder, at den sidste karakter i en streng vil have en position, der er strengens længde minus 1:

Længden af en streng og positionen af tegnene

Streng litteraler er deklarerede med dobbelt anførselstegn ("" eller enkelt anførselstegn (''). Java deklarerer strenge med dobbelt anførselstegn og tegn med enkelt anførselstegn. Men da ECMAScript ikke har en tegn-type, kan begge disse repræsentationer bruges. For eksempel er de to følgende linjer gyldige:

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

String-typen inkluderer også flere tegn litteraler, som Java-, C- og Perl-udviklere bør være meget bekendte med.

Nedenunder er listen over ECMAScript's tegn litteraler:

litteral betydning
\n linjeskift
\t tabulator
\b mellemrum
\r enter
\f sidebryd
\\\ bakspejl
\' enkel anførselstegn
\" dobbelt anførselstegn
\0nnn octal kode nnn repræsenterer tegnet)n er en af de otte cifre mellem 0 og 7)
\xnn hexadecimal kode nn repræsenterer tegnet)n er en af de sekstenadskilte tal mellem 0 og F)
\unnnn hexadecimal kode nnnn repræsenterer en Unicode-tegn)n er en af de sekstenadskilte tal mellem 0 og F)