JavaScript基礎

JavaScript基礎

一、什麼是JavaScript

JavaScript 是 Microsoft 公司對 ECMA 262 語言規範（ECMAScript 編輯器 3）的一種實現。除了少數例外（爲了保持向後兼容），JavaScript 完全實現了 ECMA 標準。本概述的目的就是引導您學習使用 JavaScript。

1、使用 JavaScript

JavaScript 是一種解釋型的、基於對象的腳本語言。儘管與 C++ 這樣成熟的面向對象的語言相比，JavaScript 的功能要弱一些，但對於它的預期用途而言，JavaScript 的功能已經足夠大了。

JavaScript 不是其他語言的精簡版（例如，它只是與 Java 有點模糊而間接的關係），也不是任何事物的簡化。不過，它有其侷限性。例如，您不能使用該語言來編寫獨立運行的應用程序，並且沒有對讀寫文件的內置支持。此外，JavaScript 腳本只能在某個解釋器或“宿主”上運行，如 Active Server Pages（ASP）、Internet 瀏覽器或者 Windows 腳本宿主。

JavaScript 是一種寬鬆類型的語言。寬鬆類型意味着您不必顯式定義變量的數據類型。事實上 JavaScript 更進一步。您無法在JavaScript 上明確地定義數據類型。此外，在大多數情況下，JavaScript 將根據需要自動進行轉換。例如，如果將一個數值添加到由文本組成的某項（一個字符串），該數值將被轉換爲文本。

二、編寫JavaScript代碼

與其他許多編程語言一樣，JavaScript 是用文本方式編寫的，並被組織成爲語句、由相關的語句集組成的塊、以及註釋。在一條語句內可以使用變量、比如字符串和數字（稱爲“文字”）的立即數、以及表達式。

1、語句

JavaScript 程序是語句的集合。一條 JavaScript 語句相當於英語中的一個完整句。JavaScript 語句將表達式組合起來，完成一個任務。一條語句由一個或多個表達式、關鍵字或者運算符（符號）組成。典型地，一條語句寫一行，儘管一條語句可以超過兩行或更多行。兩條或更多條語句也可以寫在同一行上，語句之間用分號“;”隔開。通常，每一新行開始一條新語句。不過顯式地終止語句是一個好方法。這是用分號 (;)來實現的，分號是 JavaScript 語句的終止字符。下面給出 JavaScript 語句的兩隔示例。

aBird = "Robin"; //將文本“Robin”賦值給變量 aBird
var today = new Date(); // 將今天的日期賦值給變量 today

用大括號（{}）括起來的一組 JavaScript 語句稱爲一個語句塊。分組到一個語句塊中的語句通常可當作單條語句處理。這就是說在 JavaScript 期望有一條單個語句的大多數地方可以使用語句塊。應該注意以 for 和 while 打頭的循環語句是例外情況。注意，語句塊中的原始語句以分號結束，但語句塊本身並不以分號結束。通常，在函數和條件語句中使用語句塊。注意，JavaScript 與 C++ 以及其他某些語言不同，它不認爲語句塊是一個新的範圍；只有函數創建新範圍。在下面的示例中，第一條語句開始定義一個函數，該函數包含一個五條語句組成的語句塊。語句塊後的三條語句沒有用大括號括起來；這些語句不是一個語句塊，所以就不是函數定義的一部分。

function convert(inches)  {
   feet = inches / 12;  //  這五條語句屬於一個語句塊。
   miles = feet / 5280;
   nauticalMiles = feet / 6080;
   cm = inches * 2.54;
   meters = inches / 39.37;
}
km = meters / 1000;  //  這三條語句不在語句塊內。
kradius = km;
mradius = miles;

2、註釋

單行的 JavaScript 註釋以一對正斜槓(//)開始。下面給出一個單行註釋的示例。

aGoodIdea = "Comment your code thoroughly.";  //  這是一個單行註釋。

多行註釋以一個正斜槓加一個星號的組合(/)開始,並以其逆向順序 (/)結束。

/*
這是一個用來解釋前面的代碼語句的多行註釋。
​
該語句將一個值賦給 aGoodIdea 變量。
用引號包含的這種值稱爲一個文字。
文字顯式並直接包含信息；
而不是簡接地引用信息。
（引號不屬於該文字的內容。）
*/

注意：如果您試圖將一個多行註釋插入到另一箇中，JavaScript 不能按正常的方式解釋生成的多行註釋。標明嵌入的多行註釋結束的 */ 被認爲是整個多行註釋的結尾。這就意味着嵌入多行註釋之後的文本不再被認爲是註釋；相應地，它將被解釋爲 JavaScript 代碼，並會產生語法錯誤。建議將所有的註釋寫爲單行註釋的語句塊。這樣您以後就能夠將大段的代碼與多行註釋區分開。

//這是另一種多行註釋，寫成一系列單行註釋。
​
//  在執行完該語句後，可以使用 aGoodIdea 變量的名字來引用其內容，
//  如下一條語句那樣，即採用連接操作將字符串文字添加到
//  aGoodIdea 變量，以創建一個新的變量。
​
var extendedIdea = aGoodIdea + " You never know when you'll have to figure out what it does.";

3、賦值和相等

JavaScript 語句中使用等號 (=)給變量賦值：等號是賦值運算符。= 運算符左邊的操作項總是一個 Lvalue。Lvalue 可以是：

• 變量，

• 數組元素，

• 對象屬性。

= 運算符右邊的操作項總是一個 Rvalue。Rvalues 可以是任何類型的一個任意值，包括表達式的值。下面給出一個 JavaScript 賦值語句的示例。

anInteger = 3;

JavaScript 編譯器解釋本語句的意義爲：“將 3 賦給變量 anInteger”或“anInteger 的值爲 3”。

確定您理解了 = 運算符（賦值）和 == 運算符（相等）的差異。在比較兩個值是否相等時，應使用兩個等於號 (==)。這些內容將在控制程序的流程中詳細介紹。

4、表達式

JavaScript 表達式是指 JavaScript 解釋器能夠計算生成值的 JavaScript “短語”。這個值可以是任何有效的 JavaScript 類型 — 數字、字符串、對象，等等。最簡單的表達式是文字。下面給出 JavaScript 文字表達式的一些示例。

3.9                       // 數字文字
"Hello!"                  // 字符串文字
false                     // 布爾文字
null                      // 文字空值
{x:1, y:2}                // 對象文字
[1,2,3]                   // 數組文字
function(x){return x*x;}  // 函數文字

更多複雜的表達式中包含變量、函數、函數調用以及其他表達式。可以用運算符將表達式組合，創建複合表達式。運算符可以是：

+  // 加法
-  // 減法
*  // 乘法
/  // 除法

三、JavaScript的變量

任何編程語言中，用一塊數據量化一個概念。在 JavaScript 中，變量是給概念的名稱；它代表了給出瞬間的值。當使用該變量時，實際是用的它所代表的數據。給出示例：

NumberOfDaysLeft = EndDate – TodaysDate;

機械的理解是使用變量來存儲、得到並操作腳本中出現的所有的不同值。創建有意義的變量名稱；便於別人理解腳本。

1、變量聲明

變量在腳本中的第一次出現是在聲明中。變量在第一次用到時就設置於內存中，便於後來在腳本中引用。使用變量之前先進行聲明。可以使用 var 關鍵字來進行變量聲明。

var count;  // 單個聲明。
var count, amount, level;  // 用單個 var 關鍵字聲明的多個聲明。
var count = 0, amount = 100;  // 一條語句中的變量聲明和初始化。

如果在 var 語句中沒有初始化變量，變量自動取 JavaScript 值 undefined。儘管並不安全，但聲明語句中忽略 var 關鍵字是合法的 JavaScript 語法。這時，JavaScript 解釋器給予變量全局範圍的可見度。當在過程級中聲明一個變量時，它不能用於全局範圍；這種情況下，變量聲明必須用 var 關鍵字。

2、變量命名

變量名稱是一個標識符。JavaScript 中，用標識符來：

• 命名變量，

• 命名函數，

• 給出循環的標籤。

JavaScript 是一種區分大小寫的語言。因此變量名稱 myCounter 和變量名稱 mYCounter是不一樣的。變量的名稱可以是任意長度。創建合法的變量名稱應遵循如下規則：

• 第一個字符必須是一個 ASCII 字母（大小寫均可），或一個下劃線(_)。注意第一個字符不能是數字。

• 後續的字符必須是字母、數字或下劃線。

• 變量名稱一定不能是 [保留字]。（保留字在文章最後會有說到）

下面給出合法變量名稱的一些示例：

_pagecount 
Part9 
Number_Items 

下面給出無效變量名稱的一些示例：

99Balloons // 不能以數字開頭。
Smith&Wesson // “與”符號（&）字符用於變量名稱是無效的。

當要聲明一個變量並進行初始化，但又不想指定任何特殊值，可以賦值爲 JavaScript 值 null。

示例：

var bestAge = null;
var muchTooOld = 3 * bestAge; // muchTooOld 的值爲 0。

如果聲明瞭一個變量但沒有對其賦值，該變量存在，其值爲JavaScript 值 undefined。

示例:

var currentCount;
var finalCount = 1 * currentCount; // finalCount 的值爲 NaN，因爲 currentCount 爲 undefined。

注意：在 JavaScript 中 null 和 undefined 的主要區別是 null 的操作象數字 0，而 undefined 的操作象特殊值NaN （不是一個數字）。對 null 值和 undefined 值作比較總是相等的。

可以不用 var 關鍵字聲明變量，並賦值。這就是隱式聲明。

noStringAtAll = ""; // 隱式聲明變量 noStringAtAll。

不能使用未經過聲明的變量。

var volume = length * width; // 錯誤 — length 和 width 並不存在。

3、強制轉換

表達式中操作項的數據類型相同時 JavaScript 解釋器才能對其求值。如果表達式不經過強制轉換就試圖對兩個不同的數據類型（如一個爲數字，另一個爲字符串）執行運算，將產生錯誤結果。但在 JavaScript 中情況就不同了。

JavaScript 是一種自由類型的語言。它的變量沒有預定類型（相對於強類型語言，如 C++、Java、.net）。相反，JavaScript 變量的類型相應於他們包含的值的類型。這種操作的好處是能將值作爲另一類型處理。

在 JavaScript 中，可以對不同類型的值執行運算，不必擔心 JavaScript 解釋器產生異常。相反，JavaScript 解釋器自動將數據類型之一改變（強制轉換）爲另一種數據類型，然後執行運算。例如：

運算	結果
數值與字符串相加	將數值強制轉換爲字符串。
布爾值與字符串相加	將布爾值強制轉換爲字符串。
數值與布爾值相加	將布爾值強制轉換爲數值。

考慮下面的示例。

var x = 2000;      // 一個數字。
var y = "Hello";   // 一個字符串。
x = x + y;         // 將數字強制轉換爲字符串。
document.write(x); // 輸出 2000Hello。

要想顯式地將字符串轉換爲整數，使用 parseInt 方法。要想顯式地將字符串轉換爲數字，使用 parseFloat 方法。請注意，比較大小時字符串自動轉換爲相等的數字，但加法（連接）運算時保留爲字符串。

四、JavaScript的數據類型

JavaScript 有三種主要數據類型、兩種複合數據類型和兩種特殊數據類型。

主要（基本）數據類型是：

• 字符串

• 數值

• 布爾

複合（引用）數據類型是：

• 對象

• 數組

特殊數據類型是：

• Null

• Undefined

1、字符串數據類型

一個字符串值是排在一起的一串零或零以上的 Unicode 字符（字母、數字和標點符號）。字符串數據類型用來表示 JavaScript 中的文本。腳本中可以包含字符串文字，這些字符串文字放在一對匹配的的單引號或雙引號中。字符串中可以包含雙引號，該雙引號兩邊需加單引號，也可以包含單引號，該單引號兩邊需加雙引號。下面是字符串的示例：

"Happy am I; from care I’m free!"
'"Avast, ye lubbers!" roared the technician.' 
"42"
'c'

注意：JavaScript 中沒有表示單個字符的類型（如 C++ 的 char）。要表示 JavaScript 中的單個字符，應創建一個只包含一個字符的字符串。包含零個字符（""）的字符串是空（零長度）字符串。

2、數值數據類型

在 JavaScript 中整數和浮點值沒有差別；JavaScript 數值可以是其中任意一種（JavaScript 內部將所有的數值表示爲浮點值）。

3、整型值

整型值可以是正整數，負整數和 0。可以用 10 進制，8 進制和 16 進制來表示。在 JavaScript 中大多數字是用十進制表示的。加前綴“0”表示 8 進制的整型值，只能包含 0 到 7 的數字。前綴爲“0”同時包含數字“8”或“9”的數被解釋爲十進制數。

加前綴“0x”（零和x|X）表示 16 進制整型值。可以包含數字 0 到 9，以及字母 A 到 F（大寫或小寫）。使用字母 A 到 F 表示十進制 10 到 15 的單個數字。就是說 0xF 與 15 相等，同時 0x10 等於 16。

八進制和十六進制數可以爲負，但不能有小數位，同時不能以科學計數法（指數）表示。

4、浮點值

浮點值爲帶小數部分的數。也可以用科學計數法來表示。這就是說，大寫或小寫“e”用來表示 10 的次方。JavaScript用數值表示的八字節 IEEE754 浮點標準。這意味着數字最大可以到±1.7976931348623157x10308，最小到±5x10-324。以“0”開始且包含小數點的數字被解釋爲小數浮點數。注意以“0x”或“00”開始幷包含小數點的數將發生錯誤。以下是 JavaScript 中數字的例子。

數字	描述	等價十進制數
.0001, 0.0001, 1e-4, 1.0e-4	四個相等的浮點數。	0.0001
3.45e2	浮點數。	345
42	整數。	42
0378	整數。雖然看起來是八進制數（以0開頭），但是8不是有效的八進制數字，所以爲十進制數。	378
0377	八進制整數。注意它雖然看起來比上面的數只小1，但實際數值有很大不同。	255
0.0001	浮點數。雖然以零開頭，但由於帶有小數點所以不是八進制數。	0.0001
00.0001	錯誤。兩個零開頭表示爲八進制，但八進制數不能帶有小數部分。	N/A （編譯錯誤）
0Xff	十六進制整數。	255
0x37CF	十六進制整數。	14287
0x3e7	十六進制整數。注意‘e’並不被認爲指數。	999
0x3.45e2	錯誤。十六進制數不能有小數部分。	N/A （編譯錯誤）

另外，JavaScript包含特殊值數字。它們是：

• NaN （不是數）：當對不適當的數據進行數學運算時使用，例如字符串或未定義值。

• POSITIVE_INFINITY （正無窮大）：在JavaScript中如果一個正數太大的話使用它來表示。

• NEGATIVE_INFINITY （負無窮大）：在JavaScript中如果一個負數太大的話使用它來表示。

• +0和-0：JavaScript區分正0和負0。

c(-0); // -0  
c(-0 === +0); // true  
c((-0).toString()); // 0  
c( (+0).toString()); // 0  
c( -0 < +0 ); //false  
c( +0 < -0 ); //false  

5、Boolean數據類型

儘管字符串和數字類型可以有無數不同的值，boolean 數據類型卻只有兩個值。它們是文字 true 和 false。Boolean值是一個真值，它表示一個狀態的有效性（說明該狀態爲真或假）。

腳本中的比較通常得到一個 Boolean 結果。考慮以下一行 JavaScript 代碼。

y = (x == 2000);

這裏要比較變量 x 的值是否與數字 2000 相等。如果相等，比較的結果爲 Boolean 值 true，並將其賦給變量 y。如果x與2000不等，則比較的結果爲boolean值false。

Boolean值在結構控制中尤其有用。可以將直接創建 boolean 值的比較與用使用該 boolean 值的語句相組合。考慮下面的JavaScript代碼範例。

if (x == 2000)
    z = z + 1;
else
    x = x + 1;

當 boolean 值爲 true 時，JavaScript 中的 if/else 語句執行一個操作（這樣，z = z + 1），而當 boolean 值爲 false 時執行另一個操作（x = x + 1）。

可以使用任意表達式作比較表達式。任何值爲0、null、未定義或空字符串的表達式被解釋爲 false。其他任意值的表達式解釋爲 true。例如，可以使用如下表達式：

if (x = y + z) // 這可能不是想要的結果 – 如下！

注意上面的代碼並不檢查 x 是否與 y+z 相等，因爲僅使用了一個等號（賦值）。相反的，上面的代碼將 y+z 賦給變量 x，然後檢查整個表達式的值是否爲零。要檢查 x 是否與 y+z 相等，使用如下代碼。

if (x == y + z) // 這與上面的代碼不同！

6、Null 數據類型

在 JavaScript 中數據類型 null 只有一個值：null。關鍵字 null 不能用作函數或變量的名稱。包含 null 的變量包含“無值”或“無對象”。換句話說，該變量沒有保存有效的數、字符串、boolean、數組或對象。可以通過給一個變量賦 null 值來清除變量的內容。請注意，在 JavaScript 中，null 與 0 不相等（與在 C 和 C++ 中不同）。同時應該指出的是，JavaScript中 typeof 運算符將報告 null 值爲 Object 類型，而非類型 null。這點潛在的混淆是爲了向下兼容。

7、Undefined 數據類型

如下情況使返回 undefined 值：

• 對象屬性不存在，

• 聲明瞭變量但從未賦值。

注意不能通過與 undefined 做比較來測試一個變量是否存在，雖然可以檢查它的類型是否爲“undefined”。

在以下的代碼範例中，假設程序員想測試是否已經聲明變量 x ：

// 這種方法不起作用
if (x == undefined)
    // 作某些操作
​
// 這個方法同樣不起作用- 必須檢查
// 字符串 "undefined"
if (typeof(x) == undefined)
    // 作某些操作
​
// 這個方法有效
if (typeof(x) == "undefined")
    // 作某些操作

考慮將 undefined 值與null做比較。

someObject.prop == null;

如下情況時，比較的結果爲 true，

• 如果屬性 someObject.prop 包含 null 值，

• 如果屬性 someObject.prop 不存在。

• 要檢查一個對象屬性是否存在，可以使用新的 in 運算符：

if ("prop" in someObject)
// someObject 有屬性 'prop'

五、JavaScript的運算符

JavaScript 具有全範圍的運算符,包括算術、邏輯、位、賦值以及其他某些運算符。

1、算術運算符

負值：-

遞增：++

遞減：--

乘法：*

除法：/

取模運算（求餘）：%

加法：+

減法：-

2、邏輯運算符

大於：>

小於：<

小於等於：<=

大於等於：>=

等於：==

不等於：!=

邏輯非：!

邏輯與：&&

邏輯或：||

條件運算符（三目（三元）運算符）：?:

逗號：，

嚴格相等：===

非嚴格相等：!==

== （相等）與 === （嚴格相等）的區別在於恆等運算符在比較前強制轉換不同類型的值。例如，恆等對字符串 "1" 與數值 1 的比較結果將爲 true。而嚴格相等不強制轉換不同類型的值，因此它認爲字符串 "1" 與數值 1 不相同。基本的字符串、數值和布爾值是按值比較的。如果它們的值相同，比較結果爲相等。對象（包括Array、Function、String、Number、Boolean、Error、Date以及 RegExp 對象）按引用比較。即使這些類型的兩個變量具有相同的值，只有在它們正好爲同一對象時比較結果才爲 true。

例如：

// 具有相同值的兩個基本字符串。
var string1 = "Hello";
var string2 = "Hello";
​
// 具有相同值的兩個 String 對象。
var StringObject1 = new String(string1);
var StringObject2 = new String(string2);
​
// 比較結果爲 true。
if (string1 == string2)
     // 執行某些命令（將要運行的）。
​
// 比較結果爲 false。
if (StringObject1 == StringObject2)
    //執行某些命令（不會運行）。
​
// 要比較 String 對象的值， 
// 用 toString() 或者 valueOf() 方法。
if (StringObject1.valueOf() == StringObject2)
     //執行某些命令（將要運行的）。

3、位運算符

按位取反：~

按位左移：<<

按位右移：>>

無符號右移：>>>

按位與：&

按位異或：^

按位或：|

4、賦值運算符

賦值：=

運算賦值：oP=

5、其它運算符

delete運算符：從對象中刪除一個屬性，或從數組中刪除一個元素

typeof運算符：返回一個用來表示表達式的數據類型的字符串

void運算符：避免表達式返回值

instanceof運算符：返回一個 Boolean 值，指出對象是否是特定類的一個實例

new運算符：創建一個新對象

in運算符：測試對象中是否存在該屬性

六、JavaScript程序控制

JavaScript 腳本中的語句一般是按照寫的順序來運行的。這種運行稱爲順序運行，是程序流的默認方向。與順序運行不同，另一種運行將程序流轉換到腳本的另外的部分。也就是，不按順序運行下一條語句，而是運行另外的語句。要使腳本可用，該控制的轉換必須以邏輯方式執行。程序控制的轉換是基於一個“決定”，這個“決定”結果是真或假（返回 Boolean 型 true 或 false）。 創建一個表達式，然後測試其是否爲真。主要有兩種程序結構實現本功能。

第一種是選擇結構。用來指明兩種程序流方向，在程序中創建一個交叉點（像岔路）。在 JavaScript 中有四種選擇結構可用。

• 單一選擇結構（if），

• 二路選擇結構（if/else），

• 內聯三元運算符 ?:

• 多路選擇結構（switch）。

第二種類型的程序控制結構是循環結構。使用循環結構來指明當某些條件保持爲真時要重複的動作。當控制語句的條件得到滿足時（通常在某些迭代的特定數字後），控制跳過循環結構傳遞到下條語句。在 JavaScript 中有四種循環結構可用。

• 在循環的開頭測試表達式（while），

• 在循環的末尾測試表達式（do/while），

• 對對象的每個屬性都進行操作（for/in），

• 由計數器控制的循環（for）。

通過嵌套和堆棧選擇、循環控制結構，可以創建相當複雜的腳本。

第三種形式的結構程序流由意外處理給出，本文檔不作討論。

1、條件語句

JavaScript 支持 if 和 if...else條件語句。在 if 語句中將測試一個條件，如果該條件滿足測試，執行相關的 JavaScript 編碼。在 if...else 語句中，如果條件不滿足測試，則將執行不同的代碼。最簡單的 if 語句格式可以在一行中寫完，不過更常見的是多行的 if 和 if...else 語句。

下述示例演示了使用 if 和 if...else 語句的各種可能的語法。第一個示例演示了最簡單的布爾測試。當（且僅當）括號之間的項的值爲（或者可被強制轉換爲） true 時，if 後續的語句或語句塊纔會被執行。

// smash() 函數是在該代碼的其他地方定義的。
// 布爾測試，看 newShip 是否爲 true。
if (newShip)
   smash(champagneBottle,bow); 
​
// 在本示例中，除非兩個條件都爲真，否則該測試將不會被滿足。
if (rind.color == "deep yellow " && rind.texture == "large and small wrinkles")
{
   theResponse = ("Is it a Crenshaw melon?");
}
​
// 在本示例中，只要任何一個條件爲真，則測試即會滿足。
var theReaction = "";
if ((dayOfWeek == "Saturday") || (dayOfWeek == "Sunday"))
{
   theReaction = ("I'm off to the beach!");
}
else
{
   theReaction = ("Hi ho, hi ho, it's off to work I go!");
}

2、條件運算符

JavaScript 也支持隱式的條件格式。該格式在要測試的條件後使用一個問號（而不是在條件前的 if ）。它也指定兩個可選項，一個在滿足條件時使用，另一個在條件不滿足時使用。這兩個選擇項之間必須用一個冒號隔開。

var hours = "";
​
// 下面的代碼指定 hours 是包含 theHour 的內容，
// 還是包含 theHour - 12 的內容。
​
hours += (theHour >= 12) ? " PM" : " AM";

如果要一起測試多個條件，並且知道某個條件比其他條件更可能滿足或不滿足測試，可以使用稱爲“短路計算”的特性來加速腳本的運行速度。當 JavaScript 計算邏輯表達式時，只計算要得到結果所需的子表達式。

例如，如果有一個“與”表達式，如 ((x == 123) && (y == 42))，JavaScript 首先檢查 x 是否爲 123。如果不是，即使 y 等於 42，整個表達式的值也不可能爲 true。因此，並不對 y 作測試，JavaScript 返回 false 值。

類似地，如果多個條件中只要有一個爲真（使用 || 運算符），則當任何一個條件滿足該測試時測試則停止。如果要測試的條件包括函數調用或其他複合表達式，這種處理方式就有效。出於此種想法，寫 OR 表達式時，先寫最有可能爲 true 的條件。寫 AND 表達式時，先寫最有可能爲 false 的條件。

以這種方式設計腳本的好處的一個示例是：在下例中如果 runfirst() 返回 0 或 false， 則不會運行 runsecond()。

if ((runfirst() == 0) || (runsecond() == 0)) {
    // 若干代碼。
}

3、使用循環

有多種方式來重複執行一條語句或語句塊。通常重複執行被稱爲循環或重複。重複只是循環的一個運行。典型情況是用一個變量測試來進行控制，每執行一次循環變量的取值都會更改。JavaScript 支持四種循環： for循環、 for...in 循環、while 循環、 do...while 循環。

4、使用 for 循環

for 語句指定了一個計數器變量，一個測試條件，以及更新該計數器的操作。在每次循環的重複之前，都將測試該條件。如果測試成功，將運行循環中的代碼。如果測試不成功，不運循環中的代碼，程序繼續運行緊跟在循環後的第一行代碼。在執行該循環後，計算機變量將在下一次循環之前被更新。

如果循環條件永不會滿足，則不執行該循環。如果測試條件始終滿足，則將導致無限循環。在有些情況下，前者可能是合乎需要的，而後者幾乎沒有用處，因此在編寫循環條件時一定要注意。

/*
更新表達式 （下例中的 "icount++"）將在循環結束時被執行，即在構成循環主體的語句塊被執行後，在測試條件之前。
*/
​
var howFar = 10;  // 將循環次數限制爲 10。
​
var sum = new Array(howFar);  // 創建一個稱爲 sum 並具有 10 個成員的數組，這 10 個成員從 0 到 9。
var theSum = 0;
sum[0] = 0;
​
for(var icount = 0; icount < howFar; icount++)  {        // 在本例中將從 0 到 9 進行計數。
theSum += icount;
sum[icount] = theSum;
}
​
var newSum = 0;
for(var icount = 0; icount > howFar; icount++)  {        // 該循環根本不會被執行，因爲 icount 不大於 howFar。
newSum += icount;
}
​
var sum = 0;
for(var icount = 0; icount >= 0; icount++)  {        // 這是一個無限循環。
sum += icount;
}

5、使用 for...in 循環

JavaScript 提供了一種特別的循環方式來遍歷一個對象的所有用戶定義的屬性或者一個數組的所有元素。for...in 循環中的循環計數器是一個字符串，而不是數字。它包含當前屬性的名稱或者當前數組元素的下標。

下面的代碼範例應在 Internet 瀏覽器中運行，因爲它使用 alert 方法，該方法不屬於 JavaScript。

// 創建具有某些屬性的對象
var myObject = new Object();
myObject.name = "James";
myObject.age = "22";
myObject.phone = "555 1234";
​
// 枚舉（循環）對象的所有屬性
for (prop in myObject)
{
    // 顯示 "The property 'name' is James"
    window.alert("The property '" + prop + "' is " + myObject[prop]);
}

儘管 for...in 循環看起來像 VBScript 的 For Each...Next 循環，其實並不一樣。JavaScript 的 for...in 循環重複JavaScript 對象所有的屬性。VBScript 的 For Each...Next 循環重複集合中的所有項目。要循環 JavaScript 中的所有集合，需要用 Enumerator 對象。儘管某些對象（像 Internet 瀏覽器中的那些）支持 VBScript 的 For Each...Next 和 JavaScript 的 for...in 循環，但多數對象並不都支持。

6、使用 while 循環

while 循環相似於 for 循環。其不同之處是 while 循環沒有內置的計數器或更新表達式。如果希望控制語句或語句塊的循環執行，需要不只是“運行該代碼 n 次”，而是更復雜的規則，用 while 循環。下面的示例使用 Internet 瀏覽器對象模型和 while 循環來詢問用戶一個簡單的問題。

var x = 0;
while ((x != 42) && (x != null))
{
    x = window.prompt("What is my favourite number?", x);
}
​
if (x == null)
    window.alert("You gave up!");
else
    window.alert("Yep - it's the Ultimate Answer!");

注意 由於 while 循環沒有顯式的內置計數器變量，因此比其他類型的循環更容易產生無限循環。此外，由於不易發現循環條件是在何時何地被更新的，很容易編寫一個實際上從不更新條件的 while 循環。因此在編寫 while 循環時應特別小心。

同上面所提到的，在 JavaScript 中還有 do...while 循環與 while 循環相似，不同處在於它總是至少運行一次，因爲是在循環的末尾檢查條件，而不是在開頭。例如，上面的循環可以被改寫爲：

var x = 0;
do
{
    x = window.prompt("What is my favourite number?", x);
} while ((x != 42) && (x != null));
​
if (x == null)
    window.alert("You gave up!");
else
    window.alert("Yep - it's the Ultimate Answer!");

7、使用 break 和 continue 語句

在 JavaScript 中當某些條件得到滿足時，用 break語句來中斷一個循環的運行。（請注意，也用 break 語句退出一個 switch 塊。）。如果是一個 for 或者 for...in 循環，在更新計數器變量時使用 continue語句越過餘下的代碼塊而直接跳到下一個循環中。

下面的例子基於前面的示例用 break 和 continue 語句控制循環。

var x = 0;
do
{
    x = window.prompt("What is my favourite number?", x);
​
    // 判斷用戶是否選擇取消？如果是，退出循環。
    if (x == null)
        break;
​
    // 是否輸入一個數？
    // 如果是則無需要求輸入一個數。
    if (Number(x) == x)
        continue;
​
    //  要求用戶只輸入數字。
    window.alert("Please only enter in numbers!");
​
} while (x != 42)
​
if (x == null)
    window.alert("You gave up!");
else
    window.alert("Yep - it's the Ultimate Answer!");

七、JavaScript函數

JavaScript 函數執行操作，也可以返回值。某些時候是計算或比較的結果。函數又被稱爲“全局方法”。一個函數中包含有幾個操作。這樣可使得代碼更合理化。可以寫一組語句並給其命名，然後通過調用它並傳遞其需要的信息來運行整組語句。給函數傳遞信息可以把信息放在函數名稱後面的圓括號中。傳遞給函數的信息稱作參數。某些函數根本不帶任何參數，而其他函數帶一個或者多個參數。在某些函數中，參數的個數取決於如何使用該函數。

JavaScript 支持兩種函數：一類是語言內部的函數，另一類是自己創建的。

1、特殊的內部函數

JavaScript 語言包含很多內部函數。某些函數可以操作表達式和特殊字符，而其他函數將字符串轉換爲數值。一個有用的內部函數是 eval()。該函數可以對以字符串形式表示的任意有效的 JavaScript代碼求值。eval() 函數有一個參數，該參數就是想要求值的代碼。下面給出一個使用本函數的示例。

var anExpression = "6 * 9 % 7";
var total = eval(anExpression); // 將變量 total 賦值爲 5。
var yetAnotherExpression = "6 * (9 % 7)";
total = eval(yetAnotherExpression) // 將變量 total 賦值爲 12。
// 將一個字符串賦給 totality （注意嵌套引用）
var totality = eval("’...surrounded by acres of clams.’");

2、創建自己的函數

在必要的時候，可以創建並使用自己的函數。一個函數的定義中包含了一個函數語句和一個 JavaScript 語句塊。下面示例中的 Checktriplet 函數以三角形的邊長爲參數。通過查看三條邊的長度是否可以組成一個畢達哥拉斯三元組（直角三角形斜邊長度的平方等於其他兩條邊長的平方和）來計算該三角形是否爲直角三角形。實際測試時 checkTriplet 函數要調用另兩個函數中的一個函數。注意在浮點數測試版本中極小數（“epsilon”）作爲測試變量的使用。由於浮點運算的不確定性和舍入誤差，除非問題中的三個值均已知爲整數，直接測試這三個數是否組成畢達哥拉斯三元組是不可行的。因爲直接的測試更爲準確，本示例中的代碼確定其是否可行，如果可行則使用它。

var epsilon = 0.00000000001; // 一些需要測試的極小數字。
​
// 測試整數的函數。
function integerCheck(a, b, c) 
{
   // 測試。
   if ( (a*a) == ((b*b) + (c*c)) )   
      return true;
​
   return false;
} // 整數檢查函數的結尾。
​
// 測試浮點數的函數。
function floatCheck(a, b, c)   
{
   // 得到測試數值。
   var delta = ((a*a) - ((b*b) + (c*c)))
​
   // 測試需要絕對值
   delta = Math.abs(delta);
​
   // 如果差小於 epsilon，那麼它相當接近。
   if (delta < epsilon)   
      return true;
​
   return false;
} // 浮點檢查函數的末尾。
​
​
// 三元檢查。
function checkTriplet(a, b, c)
{ 
   // 創建臨時變量，用於交換值
   var d = 0; 
​
   // 先將最長的移動到位置“a”。
​
   // 需要的話交換 a 和 b
   if (b > a)
   {
      d = a;
      a = b;
      b = d;
   }
​
   // 需要的話交換 a 和 c
   if (c > a)
   {
      d = a;
      a = c;
      c = d;
   }
​
   // 測試全部的 3 個值，看其是否爲整數？
   if (((a % 1) == 0) && ((b % 1) == 0) && ((c % 1) == 0))
   { 
      // 如果成立，使用精確檢查。
      return integerCheck(a, b, c); 
   }
   else
   {
      // 如果不成立，取儘可能相近的。
      return floatCheck(a, b, c); 
   }
} // 三元檢查函數的末尾。
​
// 下面的三個語句賦給範例值，用於測試。
var sideA = 5;
var sideB = 5;
var sideC = Math.sqrt(50.001);
​
// 調用函數。調用後，'result' 中包含了結果。
var result = checkTriplet(sideA, sideB, sideC);

八、JavaScript對象

JavaScript 對象是屬性和方法的集合。一個方法就是一個函數，是對象的成員。屬性是一個值或一組值（以數組或對象的形式），是對象的成員。JavaScript 支持四種類型的對象：內部對象、生成的對象、宿主給出的對象（如 Internet 瀏覽器中的 window 和 document）以及 ActiveX 對象（外部組件）。

1、作爲數組的對象

在 JavaScript 中，對象和數組幾乎是以相同的方式處理的。對象和數組均可以被賦予任意值，實際上數組只是一種特殊的對象。數組和對象的區別在於數組有一個“奇妙的” length 屬性，而對象沒有。這意味着可以給數組的一個元素賦予比其他元素更大的值。例如，myArray[100] = "hello" — 然後 length 屬性將自動地被更新爲 101（新長度）。同樣，如果修改數組的 length 屬性，將刪除不再是數組部分的元素。JavaScript 中所有的對象均支持“expando”屬性或那些可以在運行時動態添加和刪除的屬性。這些屬性可以有包含數字的任意名稱。如果屬性的名稱是簡單的標識符<<參考標識符規則>>，可以在對象名稱的後面加句點，例如：

var myObj = new Object();
​
// 添加兩個 expando 屬性，'name' 和 'age'
myObj.name = "Fred";
myObj.age = 42;

如果屬性名稱不是一個簡單的標識符，或者在寫腳本的時候不知道，可以在方括號中使用任意表達式來索引屬性。在 JavaScript 中所有 expando 屬性的名稱在被添加到對象之前被轉換爲字符串。

var myObj = new Object();
​
// 添加兩個無法寫在 object.property 語
// 法中的 expando 屬性。
// 第一個屬性包含無效字符（空格），
// 所以必須寫在方括號裏。
myObj["not a valid identifier"] = "This is the property value";
​
// 第二個 expando 名稱是一個數字，
// 所以也必須寫在方括號裏。
myObj[100] = "100";

傳統的作法是賦給數組元素以 0 開始的數字索引。這些數組元素與 length 屬性相交互。然而，由於所有的數組也是對象，也支持 expando 屬性。請注意，雖然如此，expando 屬性並不以任何方式與 length 屬性相交互。例如：

// 三個元素的數組
var myArray = new Array(3);
​
// 添加數據
myArray[0] = "Hello";
myArray[1] = 42;
myArray[2] = new Date(2000, 1, 1);
​
// 顯示數組的長度 3
window.alert(myArray.length);
​
// 添加某些 expando 屬性
myArray.expando = "JavaScript!";
myArray["another Expando"] = "Windows";
​
// 仍然顯示 3，因爲兩個 expando 屬性
// 並不影響長度。
window.alert(myArray.length);

雖然 JavaScript 並不直接支持多維數組，但是可以在數組元素中存儲任意種類的數據 — 包含其他數組。所以通過在另一個數組的元素裏存儲其他數組可以得到多維數組的特性。例如，下面的代碼爲最大爲 5 的數字建立了乘法表：

// 若是更大的表請改變本數
var iMaxNum = 5;
// 循環計數
var i, j;
​
// 新數組。由於數組從 0 開始計數，
// 而不是 1，所以數組大小爲 iMaxNum + 1。
var MultiplicationTable = new Array(iMaxNum + 1);
​
// 爲每個主要的數做循環（表中的每一行）
for (i = 1; i <= iMaxNum; i++)
{
    // 生成表中的列
    MultiplicationTable[i] = new Array(iMaxNum + 1);
​
    // 將乘法的結果存在行中
    for (j = 1; j <= iMaxNum; j++)
    {
        MultiplicationTable[i][j] = i * j;
    }
}
​
window.alert(MultiplicationTable[3][4]); // 顯示 12
window.alert(MultiplicationTable[5][2]); // 顯示 10
window.alert(MultiplicationTable[1][4]); // 顯示 4

2、創建自己的對象

要創建自己的對象實例，必須首先爲其定義一個構造函數。構造函數創建一個新對象，賦予對象屬性，並在合適的時候賦予方法。例如，下面的示例爲 pasta 對象定義了構造函數。注意 this 關鍵字的使用，它指向當前對象。

// pasta 是有四個參數的構造器。
function pasta(grain, width, shape, hasEgg)
{
    // 是用什麼做的？
    this.grain = grain;
​
    // 多寬？（數值）
    this.width = width;     
​
    // 形狀？（字符串）
    this.shape = shape;   
​
    // 是否加蛋？（boolean）
    this.hasEgg = hasEgg;  
}

定義了對象構造器後，用 new 運算符創建對象實例。

var spaghetti = new pasta("wheat", 0.2, "circle", true);
var linguine = new pasta("wheat", 0.3, "oval", true);

可以給對象實例添加屬性以改變該實例，但是用相同的構造器生成的其他對象定義中並不包括這些屬性，而且除非你特意添加這些屬性那麼在其他實例中並不顯示出來。如果要將對象所有實例的附加屬性顯示出來，必須將它們添加到構造函數或構造器原型對象（原型在高級文檔中討論）中。

// spaghetti 的附加屬性。
spaghetti.color = "pale straw";
spaghetti.drycook = 7;
spaghetti.freshcook = 0.5;
​
var chowFun = new pasta("rice", 3, "flat", false); 
// chowFun 對象或其他現有的 pasta 對象
// 都沒有添加到 spaghetti 對象
// 的三個新屬性。
​
​
// 將屬性‘foodgroup’加到 pasta 原型對象
// 中，這樣 pasta 對象的所有實例都可以有該屬性，
// 包括那些已經生成的實例。
pasta.prototype.foodgroup = "carbohydrates"
​
// 現在 spaghetti.foodgroup、chowFun.foodgroup，等等
// 均包含值“carbohydrates”。

在定義中包含方法

可以在對象的定義中包含方法（函數）。一種方法是在引用別處定義的函數的構造函數中添加一個屬性。例如，下面的示例擴充上面定義的 pasta 構造函數以包含 toString 方法，該方法將在顯示對象的值時被調用。

// pasta 是有四個參數的構造器。
// 第一部分與上面相同。
function pasta(grain, width, shape, hasEgg)
{
    // 用什麼糧食做的？
    this.grain = grain;
​
    // 多寬？（數值）
    this.width = width;     
​
    // 橫截面形狀？（字符串）
    this.shape = shape;   
​
    // 是否加蛋黃？（boolean）
    this.hasEgg = hasEgg;  
​
    // 這裏添加 toString 方法（如下定義）。
    // 注意在函數的名稱後沒有加圓括號；
    // 這不是一個函數調用，而是
    // 對函數自身的引用。
    this.toString = pastaToString;
}
​
// 實際的用來顯示 past 對象內容的函數。 
function pastaToString()
{
    // 返回對象的屬性。
​
    return "Grain: " + this.grain + "\n" +
        "Width: " + this.width + "\n" +
        "Shape: " + this.shape + "\n" +
        "Egg?: " + Boolean(this.hasEgg);
}
​
var spaghetti = new pasta("wheat", 0.2, "circle", true);
// 將調用 toString() 並顯示 spaghetti 對象
// 的屬性（需要Internet 瀏覽器）。
window.alert(spaghetti);

3、JavaScript內部對象

JavaScript 提供了 11 個內部（或“內置”）對象。它們是Array、Boolean、Date、Function、Global、Math、Number、Object、RegExp、Error 以及 String 對象。

1.Array 對象

數組下標可以被認爲是對象的屬性，它是通過數字索引來引用的。注意添加到數組中的已命名的屬性不能通過數字來索引；它們是與數組元素分離的。

使用 new 運算符和 Array() 構造器 生成一個新的數組，如下面的示例。

var theMonths = new Array(12);
theMonths[0] = "Jan";
theMonths[1] = "Feb";
theMonths[2] = "Mar";
theMonths[3] = "Apr";
theMonths[4] = "May";
theMonths[5] = "Jun";
theMonths[6] = "Jul";
theMonths[7] = "Aug";
theMonths[8] = "Sep";
theMonths[9] = "Oct";
theMonths[10] = "Nov";
theMonths[11] = "Dec";

用關鍵字 Array 生成數組時，JavaScript 包含了 length 屬性，該屬性記錄了數組入口數。如果沒有給該屬性指定值，則設置長度爲 0 且數組沒有入口點。如果指定一個數值，則將長度設置爲該數。如果指定了不止一個參數，則這些參數被用作數組的入口。另外，參數的數目被賦給 length 屬性。如下面的示例與前一個示例是等價的。

var theMonths = new Array("Jan", "Feb", "Mar", "Apr", "May", "Jun", 
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec");

當向用關鍵字 Array 生成的數組中添加元素時，JavaScript 自動改變屬性 length 的值。JavaScript 中的數組索引總是以 0 開始，而不是 1，所以屬性 length 通常比數組的最大索引大 1。

2.String對象

在 JavaScript 中，可以將字符串（和數）當作對象來處理。string 對象有一些內置方法，可以和自己的字符串一起使用。其中一個是substring 方法，它返回字符串的一部分。該方法以兩個數字作爲參數。

aString = "0123456789";
var aChunk = aString.substring(4, 7);  // 將 aChunk 設爲 "456"。
var aNotherChunk = aString.substring(7, 4);  // 將 aNotherChunk 設爲 "456"。
// 使用上面生成數組的示例：
firstLetter = theMonths[5].substring(0,1);  // 將變量 firstLetter 設爲“J”。

String 對象的另一個屬性是 length 屬性。本屬性包含了字符串中的字符數（空字符串爲 0）。它是一個數值，可以直接在計算中使用。

var howLong = "Hello World".length  // 設置變量 howLong 爲 11。

3.Math 對象

Math 對象有許多預定義屬性和方法。屬性是特殊的數字。這些特殊的數字之一是 pi 值（近似 3.14159…）。這是 Math.PI 屬性，如下例所示。

// 聲明一個半徑變量並賦數值。
var circleArea = Math.PI * radius * radius;  // 注意 Math 和 PI 大寫。

Math 對象的一個內置方法是乘冪方法（或 pow），使用該方法求得指定數的冪次。下面的例子同時使用了 pi 和乘冪。

// 本公式計算給定半徑的球體的體積。
volume = (4/3)*(Math.PI*Math.pow(radius,3));

4.Date 對象

Date 對象可以被用來表示任意的日期和時間，獲取當前系統日期以及計算兩個日期的間隔。它擁有一些預定義的屬性和方法。通常，Date 對象給出星期；月份，天數和年份；以及以小時，分鐘和秒錶示的時間。該信息是基於 1970 年1 月 1 日 00:00:00.000 GMT 開始的毫秒數，其中 GMT 是格林威治標準時間（首選術語是 UTC，或者“全球標準時間”，它引用的信號是由“世界時間標準”發佈的）。JavaScript 可以處理 250,000 B.C. 到 255,000 A.D範圍內的日期。使用 new 運算符創建一個新的 Date 對象。下面的示例計算當年已過去的天數和今年剩下的天數。

/*
本示例使用前面定義的月份名稱數組。
第一條語句以“Day Month Date 00:00:00 Year”格式
對 thisIsToday 變量賦值。
*/
var thisIsToday = new Date();
​
var toDay = new Date();  //獲取今天的日期。
​
// 提取年，月，日。
var thisYear = toDay.getFullYear();
var thisMonth = theMonths[toDay.getMonth()];
var thisDay = thisMonth  + " " + toDay.getDate() + ", " + thisYear;

5.Number 對象

除了 Math 對象中可用的特殊數值屬性（例如 PI）外，在 JavaScript 中， Number 對象有幾個其他的數值屬性。

屬性	描述
MAX_VALUE	可能的最大數大約爲 1.79E+308；可以是正數或負數。（具體數值隨系統不同而有微小差別。）
MIN_VALUE	可能的最小數大約爲 2.22E-308；可以是正數或負數。（具體數值隨系統不同而有微小差別。）
NaN	特殊非數量值，“不是數值”。
POSITIVE_INFINITY	比最大正數（Number.MAX_VALUE）還要大的任意正值自動被轉換爲此值，代表正無窮大。
NEGATIVE_INFINITY	比最小的負數（負的 Number.MAX_VALUE）還小的任意值被自動轉換爲此值，代表負無窮。

Number.NaN 是一個特殊的屬性，被定義爲“不是數值”。例如被 0 除返回 NaN。試圖解析一個無法被解析爲數字的字符串同樣返回 Number.NaN。把 NaN 與任何數值或本身作比較的結果都是不相等。不能通過與 Number.NaN 比較來測試 NaN 結果，而應該使用 isNaN() 函數。

6.Boolean對象

Boolean 對象是 Boolean 數據類型的包裝器。每當 Boolean 數據類型轉換爲 Boolean 對象時，JavaScript 都隱含地使用 Boolean 對象。 很少會顯式地調用 Boolean 對象。

7.Function對象

創建新的函數

語法1：

function functionName([argname1 [, ...[, argnameN]]])
{
   body
}

語法2：

functionName = new Function( [argname1, [... argnameN,]] body );

函數 JavaScript 中的基本數據類型。語法 1 創建在必要時由 JavaScript 轉換爲 Function 對象的函數值。JavaScript 在調用函數時將用語法 2 創建的函數轉換爲 Function 對象。

語法 1 是 JavaScript 中創建函數的基本方法。語法 2 是用於顯式創建函數對象的另一方法。

例如，要創建將傳遞給它的兩個參數相加的函數，可以用兩種方法中的任一種完成：

例子1：

function add(x, y)
{
   return(x + y);            // 執行加法並返回結果。
}

例子2：

var add = new Function("x", "y", "return(x+y)");

在兩種情況下，都可以用如下代碼行調用該函數：

add(2, 3);

注意 在調用函數時，請確保包含了括號和必需的參數。調用函數時不用括號導致返回函數的文本而不是函數執行的結果。

8.Global對象

是一個固有對象，目的是把所有全局方法集中在一個對象中。Global對象沒有語法。直接調用其方法Global 對象從不直接使用，並且不能用 new 運算符創建。它在 Scripting 引擎被初始化時創建，並立即使其方法和屬性可用。

9.Object對象

Object對象提供所有 JavaScript 對象通用的功能。Object 對象被包含在所有其它 JavaScript 對象中；在所有其它對象中它的方法和屬性都是可用的。在用戶定義的對象中可以重定義這些方法，並在適當的時候通過 JavaScript 調用。toString 方法是經常被重定義的 Object 方法的例子。

10.RegExp 對象

保存有關正則表達式模式匹配信息的固有全局對象。RegExp 對象不能直接創建，但始終可以使用。在成功的正則表達式查找完成之前，RegExp 對象各屬性的初始值如下所示：

屬性	簡寫	初始值
index		-1
lastIndex		-1
lastMatch	$&	空字符串。
lastParen	$+	空字符串。
leftContext		空字符串。
rightContext		空字符串。
​9	​9	空字符串。

在成功的正則表達式查找完成之前，其屬性值爲 undefined。

不要將全局 RegExp 對象與 正則表達式 對象混淆。儘管聽起來像是一回事，但它們是截然不同的。全局 RegExp 對象的屬性包含不斷更新的關於每個匹配出現的信息，而正則表達式對象只包含出現正則表達式匹配的信息。

示例：下面的例子演示了全局 RegExp 對象的用法。

function matchDemo(){
   var s;
   var re = new RegExp("d(b+)(d)","ig");
   var str = "cdbBdbsbdbdz";
   var arr = re.exec(str);
   s = "$1 contains: " + RegExp.$1 + "\n";
   s += "$2 contains: " + RegExp.$2 + "\n";
   s += "$3 contains: " + RegExp.$3;
   return(s);
}

11.Error 對象

Error對象用於保存有關錯誤的信息。

var newErrorObj = new Error(
)
var newErrorObj = new Error(
  number
)
var newErrorObj = new Error(
  number,
  description
)
//number：與錯誤相聯的數字值。如果省略則爲零。
//description：描述錯誤的簡短字符串。如果省略則爲空字符串。

每當產生運行時錯誤，就產生 Error 對象的一個實例以描述錯誤。該實例有兩個固有屬性保存錯誤的描述（description 屬性）和錯誤號（number 屬性）。錯誤號是 32 位的值。高 16 位字是設備代碼，而低字是實際的錯誤代碼。Error 對象也可以用如上所示的語法顯式創建，或用 throw 語句拋掉。在兩種情況下，都可以添加選擇的任何屬性，以拓展 Error 對象的能力。典型地，在 try...catch 語句中創建的局部變量引用隱式創建的 Error 對象。因此，可以按選擇的任何方法使用錯誤號和描述。下面的例子演示了隱式創建 Error 對象的使用：

try
 { x = y                           // 產生錯誤。
}catch(e){                         // 創建局部變量 e。
  response.write(e)                  // 打印 "[object Error]".
  response.write(e.number & 0xFFFF)  // 打印 5009。
  response.write(e.description)      // 打印 "'y' is undefined".
}

九、JavaScript保留關鍵字

JavaScript 有一些保留字不能在標識符中使用。保留字對 JavaScript 語言有特殊的含義，它們是語言語法的一部分。使用保留字在加載腳本的時候將產生編譯錯誤。JavaScript 還有一些留作將來使用的保留字。這些字不是現在的 JavaScript 語言的一部分，然而它們是爲將來的使用保留的。

1、保留詞

break	delete	function	return	typeof
case	do	if	switch	var
catch	else	in	this	void
continue	false	instanceof	throw	while
debugger	finally	new	true	with
default	for	null	try

2、爲將來保留的詞

abstract	double	goto	native	static
boolean	enum	implements	package	super
byte	export	import	private	synchronized
char	extends	int	protected	throws
class	final	interface	public	transient
const	float	long	short	volatile

注：當選擇標識符時避免使用已經在內部 JavaScript 對象或函數中使用的詞，如 String 或 parseInt。

十、使用消息框

1、使用警告、提示和確認

可以使用警告、確認和提示消息框來獲得用戶的輸入。這些消息框是 window 對象的接口方法。由於 window 對象位於對象層次的頂層，因此實際應用中不必使用這些消息框的全名（例如 "window.alert()"），不過採用全名是一個好注意，這樣有助於您記住這些消息框屬於哪個對象。

2、警告消息框

alert 方法有一個參數，即希望對用戶顯示的文本字符串。該字符串不是 HTML 格式。該消息框提供了一個“確定”按鈕讓用戶關閉該消息框，並且該消息框是模式對話框，也就是說，用戶必須先關閉該消息框然後才能繼續進行操作。

window.alert("歡迎！請按“確定”繼續。");

3、確認消息框

使用確認消息框可向用戶問一個“是-或-否”問題，並且用戶可以選擇單擊“確定”按鈕或者單擊“取消”按鈕。confirm 方法的返回值爲 true 或 false。該消息框也是模式對話框：用戶必須在響應該對話框（單擊一個按鈕）將其關閉後，才能進行下一步操作。

var truthBeTold = window.confirm("單擊“確定”繼續。單擊“取消”停止。");
if (truthBeTold) {
window.alert("歡迎訪問我們的 Web 頁！");
}  else  window.alert("再見啦！");

4、提示消息框

提示消息框提供了一個文本字段，用戶可以在此字段輸入一個答案來響應您的提示。該消息框有一個“確定”按鈕和一個“取消”按鈕。如果您提供了一個輔助字符串參數，則提示消息框將在文本字段顯示該輔助字符串作爲默認響應。否則，默認文本爲 "<undefined>"。

與alert( ) 和 confirm( ) 方法類似，prompt 方法也將顯示一個模式消息框。用戶在繼續操作之前必須先關閉該消息框

var theResponse = window.prompt("歡迎？","請在此輸入您的姓名。");