ECMAScript ursprungliga typer

ECMAScript har 5 ursprungliga typer (primitive type), nämligen Undefined, Null, Boolean, Number och String.

typeof-operatorn

typeof-operatorn har ett argument, nämligen den variabel eller det värde som ska kontrolleras. Till exempel:

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

När typeof-operatorn kallas för en variabel eller ett värde returneras en av följande värden:

  • undefined - om variabeln är Undefined-typ
  • boolean - om variabeln är Boolean-typ
  • number - om variabeln är Number-typ
  • string - om variabeln är String-typ
  • object - om variabeln är en referenstyp eller Null-typ

Kommentar:Du kanske frågar varför typeof-operatorn returnerar "Object" för null-värden. Detta är egentligen ett fel i JavaScripts ursprungliga implementering som ECMAScript har fortsatt att använda. Nu betraktas null som en platsättare för objekt, vilket förklarar denna motsägelse, men tekniskt sett är det fortfarande en ursprunglig värde.

Undefined-typen

Som nämnts tidigare har Undefined-typen bara ett värde, nämligen undefined. När en deklarerad variabel inte har initierats är dess standardvärde undefined.

var oTemp;

Föregående rad deklarerar variabeln oTemp utan initialvärde. Variabeln kommer att tilldelas värdet undefined, dvs. det litterära värdet för undefined-typen. Man kan använda följande kodsnutt för att testa om värdet på variabeln är undefined:

var oTemp;
alert(oTemp == undefined);

Detta kodexempel visar "true", vilket innebär att dessa två värden verkligen är lika. Man kan också använda typeof-operatorn för att visa att värdet på variabeln är undefined:

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

Tips:Värdet undefined är inte detsamma som ett odefinierat värde. Men typeof-operatorn skiljer inte verkligen mellan dessa två värden. Överväg följande kod:

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

Föregående kod skriver ut "undefined" för båda variablerna, även om endast variabeln oTemp2 inte har deklarerats. Om man använder en annan operator än typeof på oTemp2, kommer det att orsaka ett fel, eftersom andra operatorer kan användas endast på deklarerade variabler.

Till exempel kommer följande kod att orsaka ett fel:

var oTemp;
alert(oTemp2 == undefined);

När en funktion inte har ett tydligt returvärde, returneras också värdet "undefined", som visas nedan:

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

Null-typen

En annan typ med endast ett värde är Null, som har endast ett specifikt värde null, dvs. dess litterala värde. Värdet undefined är faktiskt avledet från värdet null, så ECMAScript definierar dem som lika.

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

Trots att dessa två värden är lika, har de olika innebörder. undefined är värdet som tilldelas en variabel som inte har initierats, medan null används för att representera ett objekt som inte finns (detta har enkelt introducerats när vi diskuterade typeof-operatorn). Om en funktion eller metod ska returnera ett objekt och objektet inte hittas, returneras ofta null.

Boolean-typen

Boolean-typen är en av de mest använda typerna i ECMAScript. Den har två värden true och false (dvs. de två Boolean-litterala värdena).

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

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

浮点数

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

var fNum = 5.0;

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

科学计数法

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

var fNum = 5.618e7

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

也可以用科学计数法表示非常小的数，例如 0.00000000000000008 可以表示为 8-e17(Här har 10 lyfts till -17:e potens, vilket innebär att det behöver delas med 10 17 gånger). ECMAScript konverterar som standard flyttalsvärden med 6 eller fler föregående nullor till vetenskaplig notation.

Tips:Värdet kan också lagras i 64-bitars IEEE 754-form, vilket innebär att decimalvärdet kan ha högst 17 decimaltecken. Värden efter 17 tecken avskärs, vilket kan orsaka små matematiska fel.

Speciella Number-värden

Flera speciella värden definieras också som Number-typ. De två första är Number.MAX_VALUE och Number.MIN_VALUE, som definierar de yttre gränserna för Number-värdssamlingen. Alla ECMAScript-nummer måste finnas inom dessa två värden. Emellertid kan det genererade beräkningsresultatet inte nödvändigtvis hamna inom dessa två värden.

När det genererade talet är större än Number.MAX_VALUE, tilldelas det värdet Number.POSITIVE_INFINITY, vilket innebär att det inte finns några fler numeriska värden. På samma sätt tilldelas ett beräknat värde som är mindre än Number.MIN_VALUE värdet Number.NEGATIVE_INFINITY, vilket också innebär att det inte finns några fler numeriska värden. Om beräkningen returnerar ett oändligt värde, kan det genererade resultatet inte användas i andra beräkningar.

Faktiskt finns det specifika värden som representerar oändlighet, som du kanske gissade, nämligen Infinity. Number.POSITIVE_INFINITY är värdet Infinity. Number.NEGATIVE_INFINITY är värdet -Infinity.

Eftersom oändliga tal kan vara antingen positiva eller negativa, kan man använda en metod för att avgöra om ett tal är slutligt (inte bara testa varje oändligt tal enskilt). Man kan anropa isFinite() -metoden för alla tal för att säkerställa att talet inte är oändligt. Till exempel:

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

Den sista speciella värdet är NaN, vilket betyder 'inte ett tal' (Not a Number). NaN är en konstig speciell värde. Generellt sett inträffar detta när en typ (String, Boolean etc.) misslyckas med att konverteras. Till exempel misslyckas det att konvertera ordet blue till ett nummer, eftersom det inte finns ett ekvivalent nummer. Som oändlighet kan NaN inte användas i aritmetiska beräkningar. En annan konstig egenskap hos NaN är att det inte är lika med sig själv, vilket innebär att följande kod returnerar false:

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

Av denna anledning rekommenderas det inte att använda NaN-värdet självt. Funktionen isNaN() gör ett mycket bra jobb:

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

String-typer

En unik egenskap hos String-typerna är att de är det enda ursprungliga typen som inte har en fast storlek. Man kan lagra 0 eller fler Unicode-tecken i en sträng, representerade av 16-bitars heltal (Unicode är en internationell teckenuppsättning som kommer att diskuteras i denna kurs).

Varje tecken i en sträng har en specifik position, den första tecknet börjar vid position 0, den andra tecknet vid position 1, och så vidare. Detta innebär att positionen för det sista tecknet i strängen alltid är en minus ett av strängens längd:

Strängens längd och karaktärens plats

Stränglitteraler deklareras genom dubbla citationstecken (""), enkel citationstecken ('') eller Java använder dubbla citationstecken för att deklarera strängar och enkla citationstecken för att deklarera tecken. Eftersom ECMAScript inte har ett teckentyp, kan vilket av dessa två sätt som helst användas. Exempelvis är följande två rader giltiga:

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

String-typerna inkluderar också några teckenlitteraler, utvecklare som är vana vid Java, C och Perl bör känna till dessa mycket väl.

Nedan är en lista över ECMAScript:s teckenlitteraler:

liten betydelse
\n ny rad
\t tabulator
\b mellanslag
\r returtecken
\f sidoverskridningstecken
\\\ bakåtstegstecken
\' enkel citationstecken
\" dubbel citationstecken
\0nnn oktal kod nnn representerar tecknet (n är en oktal tal mellan 0 och 7)
\xnn hexadecimal kod nn representerar tecknet (n är en sexadecimal tal mellan 0 och F)
\unnnn hexadecimal kod nnnn representerar Unicode-tecknet (n är en sexadecimal tal mellan 0 och F)