作者的序言

朋友們，棄療系列4出來啦，作者還并沒有放棄，感覺自己萌萌噠，233。

語句

js程序其實就是一系列可執(zhí)行語句的集合。只要掌握了語句，就可以開始寫js程序

默認情況下，js依照語句編寫順序依次執(zhí)行，其中有很多語句和控制語句，來改變默認執(zhí)行順序:

• 條件語句，js解釋器根據(jù)一個表達式的值來判斷是執(zhí)行還是跳過這些語句，比如if語句、switch語句
• 循環(huán)語句，可以重復執(zhí)行語句，如while語句和for語句
• 跳轉(zhuǎn)語句，可以讓解釋器跳轉(zhuǎn)至程序的其他部分繼續(xù)執(zhí)行，如break語句、return語句、 throw語句

表達式語句

• 賦值語句
• 遞增、遞減運算符
• 函數(shù)調(diào)用

greeting = "hello" + name;
i *= 3;

counter++;

delete o.x;

window.close();

cx = Math.cos(x);

復合語句和空語句

js可以講多條語句聯(lián)合在一起，形成一條復合語句，只需要用花括號將多條語句括起來即可。

下面代碼可以當成一條單獨的語句，使用在任何js希望使用一條語句的地方：

{
  x = Math.PI;
  cx = Math.cos(x);
  console.log("cos(pi) = " + cx);
}

關(guān)于語句塊，需要注意:

• 語句塊結(jié)尾不需要分號，塊中語句必須以分號結(jié)束，但語句塊不需要
• 語句塊中的縮進不是必須的，但是為了代碼可讀性，還是需要整齊的縮進更好
• js中沒有快級作用域，語句塊中聲明的變量并不是語句塊私有的

在js中，希望多條語句被當作一條語句使用時，使用復合語句來替代，空語句正好相反，允許包含0條語句
空語句如下:

;

js執(zhí)行空語句時，不會執(zhí)行任何動作。但是創(chuàng)建一個具有空循環(huán)體時，空語句很有用

for(var i=0; i<a.length; a[i++]=0) ;

注意，在for循環(huán)、while循環(huán)或if語句的右圓括號后的分號不起眼，很容易造成一些不容易定位的bug

if((a == 0) || ( b == 0)); // 這一行代碼沒有執(zhí)行任何東西
o = null;    // 這一行總會執(zhí)行

如果有特殊目的需要使用空語句，最好在代碼中注釋

聲明語句

var和function都是聲明語句，它們聲明或定義變量或函數(shù)。

var

var 語句用來聲明一個或多個變量。關(guān)鍵字var后面跟隨的是要聲明的變量列表，每個變量都可以帶有初始化表達式，用于指定初始值

栗子：

var i;
var j = 0;
var p,q;
var greeting = "hello" + name;
var x = 2.34,y = Math.cos(1), r, theta;
var x = 2,
    f = function(x) { return x*x;},
    y = f(x);

如果var語句出現(xiàn)在函數(shù)體內(nèi)，那么定義的是一個局部變量，作用域就是這個函數(shù)。

如果在頂層代碼中使用var語句，那么聲明的是一個全局變量，在整個js程序都是可見的

var聲明的變量是無法通過delete刪除的

如果var語句中的變量沒有指定初始化值，那么這個變量的值初始化為undefined

function

關(guān)鍵字function用來定義函數(shù)，例如以下函數(shù)定義表達式形式寫法來定義函數(shù)：

var f = function(x) { return x*x; };
function f(x) { return x+1; };

大括號包起來的是函數(shù)體，函數(shù)體是由js語句組成的，語句數(shù)量不限。

在定義函數(shù)時，并不執(zhí)行函數(shù)體內(nèi)的語句，它和調(diào)用函數(shù)時的新函數(shù)對象相關(guān)聯(lián)。

注意即使只有一條語句，也需要用花括號包起來。
下面是一些函數(shù)聲明形式的栗子：

function hypotense(x,y) {
  return x*x + y*y;
}

函數(shù)聲明語句通常出現(xiàn)在js代碼的最頂層，也可以嵌套在其它函數(shù)體內(nèi)。但是嵌套函數(shù)定義時，注意函數(shù)聲明只能出現(xiàn)在所嵌套函數(shù)頂部
不能出現(xiàn)在if語句、while循環(huán)或其他任何語句中

函數(shù)聲明語句和函數(shù)定義表達式的不同:

• 函數(shù)聲明語句中的函數(shù)名是一個變量名，變量指向函數(shù)對象。和通過var聲明變量一樣，函數(shù)定義語句的函數(shù)被顯式的“提前”到了腳本或函數(shù)的頂部，在整個腳本和函數(shù)內(nèi)是可見的
• 使用var的話，只有變量名被提前了，變量初始化代碼仍然在原來的位置。使用函數(shù)聲明語句的話，函數(shù)名稱和函數(shù)體均被提前。

和var語句一樣，函數(shù)聲明語句創(chuàng)建的變量是無法刪除的。

條件語句

js中基本的條件語句有if/else語句和switch語句

if語句

主要有3種形式

• if ...
• if...else...
• if...else if...else...

if ...

if (exoression)
  statement;

if...else...

if (expression)
  statement1;
else
  statement2;

if...else if...else...

if (expression1)
  statement1;
else if(expression2)
  statement2;
else
  statement3;

switch語句

如果所有的程序執(zhí)行分支都依賴于同一個表達式時，if-else并不是最佳解決方案，而switch語句正適合處理這種情況

switch(n): {
  case 1:
    // 執(zhí)行代碼塊1
    break;
  case 2:
    // 執(zhí)行代碼塊2
    break;
  case 3:
    // 執(zhí)行代碼塊3
    break;
  default:
    // 執(zhí)行代碼塊4
    break;
}

由于switch語句每次執(zhí)行時候，不是所有的case表達式都能執(zhí)行，因此，應當避免使用帶有副作用的case表達式，
最安全的做法是case中使用常量表達式

循環(huán)語句

js中有4中循環(huán)語句，while,do/while,for,for/in

while語句

while 語句基本語法如下:

while(expression)
  statement

執(zhí)行while之前，js解釋器先計算expression值，如果值是假的，那么程序?qū)⑻^循環(huán)體中的邏輯。反之，js將執(zhí)行循環(huán)體內(nèi)的邏輯，
然后再次計算表達式expression的值，這種循環(huán)會一直下去，直到expression值為假值為止。

下面這個示例演示while循環(huán)輸出0-9:

var count = 0;
while( count < 10 ){
  console.log(count++);
}

do/while語句

do/while語句和while語句非常接近，只不過檢測循環(huán)表達式是在循環(huán)結(jié)束時候，也就說至少執(zhí)行一次

do {
  statement
}while(expression)

下面是一個do/while循環(huán)的栗子：

var count = 0;
do {
  console.log(count++)
}while(count<10)

for語句

大部分循環(huán)都有特定的計數(shù)變量，在循環(huán)開始之前，初始化這個變量，然后每次循環(huán)執(zhí)行之前都檢測一下他的值，最后，
計數(shù)器變量做自增操作。

在這類循環(huán)中，計數(shù)器的三個關(guān)鍵操作是：初始化、檢測、更新

for語句將這三步操作明確聲明為循環(huán)語法一部分，各自使用一個表達式來表示。

for語句的語法如下：

for(initialize; test; increment;){
  statement
}

initialize,test,increment三個表達式之間用分號分割，分別負責初始化操作，循環(huán)條件判斷和計數(shù)器變量更新。

for循環(huán)輸出0-9的栗子：

for(var count=0; count<10;count++){
  console.log(count);
}

for/in語句

for/in語句和常規(guī)for循環(huán)完全不同。語法如下：

for(variable in object){
  statement
}

variable 通常是一個變量名，也可以是一個產(chǎn)生左值的表達式或者一個通過var語句聲明的變量，總之必須是一個適合賦值
表達式左側(cè)的值。object是一個表達式，這個表達式計算結(jié)果是一個對象。

for循環(huán)遍歷數(shù)組元素是非常簡單的，for/in循環(huán)更適合用來遍歷對象屬性成員

for(var p in o){
  console.log(o[p])
}

需要注意的是，只要for/in循環(huán)中，variable的值可以當作賦值表達式的左值，它可以是任意表達式。每次循環(huán)都會計算這個表達式，
也就是說，每次循環(huán)他計算的值都有可能不同。

例如，可以使用下面這段代碼將所有對象屬性復制到一個數(shù)組中

var o = {x:1,y:2};
var a=[],i=0;
for(a[i++] in o) ; /*empty*/

js數(shù)組不過是一種特殊的對象，因此，for/in循環(huán)可以像枚舉對象屬性一樣，枚舉數(shù)組索引。

例如可以在上面代碼之后加上這段代碼，可以枚舉數(shù)組的索引0,1,2：

for(i in a) console.log(i);

其實，for/in循環(huán)并不會遍歷對象的所有屬性，只有可枚舉的屬性才會被遍歷到。由js語言核心定義的內(nèi)置方法就不是可枚舉的.
除了內(nèi)置方法之外，還有很多內(nèi)置對象的屬性也是不可枚舉的。

代碼中定義的所有屬性和方法都是可枚舉的。

對象可以繼承其他對象的屬性，那些繼承的自定義屬性也可以使用for/in枚舉出來

屬性枚舉的順序：
規(guī)范沒有指定for/in循環(huán)按照何種順序來枚舉對象屬性，實際上主流瀏覽器廠商的js實現(xiàn)是按照屬性定義的先后順序來枚舉簡單對象的屬性：
先定義，先枚舉

跳轉(zhuǎn)語句

js中有一類語句是跳轉(zhuǎn)語句。從名字就能看出，這種語句就是使得js的執(zhí)行可以從一個位置跳轉(zhuǎn)到另一個位置。

• break語句是跳轉(zhuǎn)到循環(huán)或者其它語句的結(jié)束
• continue語句是終止本次循環(huán)的執(zhí)行并開始下一次循環(huán)的執(zhí)行。
• 跳轉(zhuǎn)到語句標簽位置
• return語句讓解釋器跳出函數(shù)體執(zhí)行，并提供本次調(diào)用的返回值
• throw語句觸發(fā)或者拋出一個異常，配合try/catch/finally語句一同執(zhí)行，跳轉(zhuǎn)到最近的閉合異常處理程序

標簽語句

語句是可以加標簽的，標簽由語句前的標示符和冒號組成identifier: statement

通過給語句定義標簽，就可以在程序的任何地方通過標簽名引用這條語句。break和continue是js唯一可以使用語句標簽
的語句.

用作標簽的identifier 必須是一個合法的js標識符，不能是保留字

標簽的命名空間和變量或函數(shù)的命名空間是不同的，因此可以使用同一個標示符作為語句標簽和作為變量名或者函數(shù)名。

一個語句標簽不能和它內(nèi)部的語句標簽重名，但在兩個代碼段不互相嵌套時候，是可以出現(xiàn)同名語句標簽。并且?guī)в袠撕灥恼Z句
還可以帶有標簽，任何語句都可以有多個標簽

比如下面這個栗子，while循環(huán)定義一個標簽，continue使用這個標簽:

mainloop: while(token != null ){
  statement1;
  continue mainloop; // 跳轉(zhuǎn)到下一次循環(huán)
  statement2;
}

break語句

單獨使用break語句的作用是立即退出最內(nèi)層的循環(huán)或者switch語句。break;

由于它能夠使循環(huán)和switch語句退出，因此這種形式的break只有出現(xiàn)在這類語句中才是合法的。

在switch中已經(jīng)見過break的用法，在循環(huán)中，無論什么原因，只要不想執(zhí)行整個循環(huán)，就可以使用break來退出

例如下面這個栗子，找到了需要查找的數(shù)組元素，就使用break退出

for(var i=0; i<a.length; i++){
  if(a[i] == target) break;
}

js同樣運行break后面跟一個語句標簽：break labelname;

當break和標簽一塊使用時候，程序跳轉(zhuǎn)到標簽所標示的語句塊的結(jié)束，或者直接終止這個閉合語句塊的執(zhí)行。
當沒有任何語句塊指定了break所用的標簽，將會產(chǎn)生一個語法錯誤

當使用帶標簽形式的break語句，帶標簽的語句不該是循環(huán)或者switch語句，因為break會跳出任何閉合的語句塊。

在break和labelname之間不能換行。因為js可以給語句自動補全省略掉分號，如果break關(guān)鍵字和標簽之間有換行，
js會認為你使用break不帶標簽的形式，會在break后補充分號

當你希望通過break跳出非就近的循環(huán)體或者switch語句，就會用到帶標簽的break語句。比如下面這個栗子：

var matrix = getData() // 得到一個二維數(shù)組
var sum=0, success = false;
compute_sum: if(matrix) {
  for(var x=0; x<matrix.length; x++){
    var row = matrix[x];
    if(!row) break compute_sum;
    for(var y=0; y<row.length; y++){
      var cell = row[y];
      if(isNaN(cell)) break compute_sum;
      sum += cell;
    }
  }
}

最后，不管break語句帶不帶標簽，他的控制權(quán)都無法越過函數(shù)邊界。比如，對于一條帶標簽的函數(shù)定義語句來說，不能
從函數(shù)內(nèi)部通過這個標簽跳轉(zhuǎn)到函數(shù)外部

continue語句

continue語句和break語句非常接近，但是不退出循環(huán)，而是執(zhí)行下一次循環(huán)。

continue語法非常簡單:continue

continue語句同樣可以帶有標簽:continue labelname

不管continue語句帶不帶標簽，只能在循環(huán)體中使用，在其他地方使用，會報語法錯誤

當執(zhí)行到continue語句時候，當前循環(huán)邏輯就終止了，隨即執(zhí)行下一次循環(huán)，在不同類型循環(huán)中，continue行為也有些不同：

• while循環(huán)，在循環(huán)開始處指定的expression會重復檢測，如果檢測結(jié)果為true，循環(huán)體從頭開始執(zhí)行
• do/while循環(huán)，程序的執(zhí)行直接跳到循環(huán)結(jié)尾處，這時會重新判斷循環(huán)條件，之后再繼續(xù)下一次循環(huán)
• for循環(huán)中，首先計算自增表達式，然后再次檢測test表達式，以判斷是否繼續(xù)執(zhí)行循環(huán)
• for/in語句中，循環(huán)開始訪問下一個屬性名，這個屬性名賦給指定的變量

需要注意的是，continue語句在while和for循環(huán)中差別，while循環(huán)直接進入下一輪的循環(huán)條件判斷，但for
循環(huán)首先計算自增表達式，然后判斷循環(huán)條件。

下面這個栗子，展示產(chǎn)生一個錯誤時候跳過當前循環(huán)后續(xù)的邏輯：

for(var i=0; i<data.length; i++){
  if(!data[!]) continue;
  total += data[i];
}

和break語句類似，帶標簽的continue語句可以嵌套在循環(huán)中，用以跳出多層次嵌套循環(huán)體邏輯。同樣的，在continue和labelname之間不能換行。

return 語句

函數(shù)調(diào)用是一種表達式，而所有的表達式都有值。函數(shù)中的return語句就是用來指定函數(shù)調(diào)用后的返回值

return語句的語法:return expression

return語句只能在函數(shù)體內(nèi)出現(xiàn)，如果不是將會報語法錯誤。當執(zhí)行到return語句時，函數(shù)終止執(zhí)行，返回expression的值

舉個栗子:

function square(x) { return x*x; }
square(2)

如果沒有return語句，則函數(shù)調(diào)用僅依次執(zhí)行函數(shù)體內(nèi)的每一條語句直到函數(shù)結(jié)束，最后返回調(diào)用程序。
這種情況下，調(diào)用表達式的結(jié)果是undefined。

return語句常作為最后一條語句出現(xiàn)，但不一定是放到函數(shù)最后，即使在執(zhí)行return語句的時候后續(xù)還有很多代碼
沒有執(zhí)行，函數(shù)還是會返回調(diào)用程序

return 語句可以單獨使用而不必帶有exoression，這樣函數(shù)調(diào)用返回的也是undefined

throw語句

異常，就是發(fā)生了某種異常情況或錯誤時產(chǎn)生的一種信號。
拋出異常，就是用信號通知發(fā)生了錯誤或異常情況。
捕獲異常，就是處理這個信號，采取必要的措施從異常中恢復。

js中，產(chǎn)生運行錯誤或者使用throw語句時就會顯式的拋出異常。使用try/catch/finally語句可以捕獲異常

throw語句的語法:throw expression;

expression的值可以是任意類型的，可以拋出一個代表錯誤碼的數(shù)字，或者可讀的錯誤消息的字符串。

js解釋器拋出異常時，通常采用Error類型和其子類型。

一個Error對象有一個name屬性表示錯誤類型，一個message屬性用來存放傳遞給構(gòu)造函數(shù)的字符串。

下面看個栗子，用非法參數(shù)調(diào)用函數(shù)時拋出一個Error對象

function factorial(x){
  // 如果輸入?yún)?shù)是非法的，則拋出一個異常
  if (x < 0) throw new Error("X 不能是負數(shù)");
  // 否則計算一個值，并返回
  for(var f = 1;x > 1; f *= x, x--) /*empty*/
}

當拋出異常時，js解釋器會立即停止當前正在執(zhí)行的邏輯，并跳轉(zhuǎn)到就近的異常處理程序。異常處理程序就是
try/catch/finally語句編寫的。
如果拋出異常的代碼塊沒有一條相關(guān)聯(lián)的catch語句塊，js解釋器會從更高層的閉合代碼塊，查看是否有關(guān)聯(lián)的
catch從句，直到找到一個異常處理程序為止。
如果拋出的異常沒有相關(guān)的異常處理函數(shù)，異常會向上傳播到調(diào)用該處的
函數(shù)的代碼，異常就會沿著js方法的詞法結(jié)構(gòu)和調(diào)用棧向上傳播，沒有任何異常處理程序，js把異常當作程序錯誤來處理，
并報告給用戶。

try/catch/finally語句

try／catch/finally語句是js的異常處理機制。

• try從句定義了需要處理的異常所在的代碼塊，
• catch從句跟在try之后，當try語句塊內(nèi)發(fā)生異常，調(diào)用catch內(nèi)的代碼邏輯。
• finally語句跟在catch之后，放置清理代碼，不管是否發(fā)生異常，finally代碼塊的邏輯總是會執(zhí)行。

try之后跟隨atch、finally語句塊可以二者只選一個，組成配合語句。

下面代碼說明了，try/catch/finally的語法和使用目的

try{
  // 通常來講，這里的代碼從頭到尾執(zhí)行不會產(chǎn)生任何問題
  // 但有時拋出一個異常，要么是throw語句直接拋出異常，
  // 要么是通過一個方法間接拋出異常
}
catch(e){
  // 當且僅當try語句拋出異常，才會執(zhí)行這里的代碼
  // 這里通過局部變量e可以獲得對Error對象或者拋出的其他值的引用
  // 還可以通過throw語句重新拋出異常
}
finally{
  // 不管是否拋出異常，這里的邏輯都會執(zhí)行，終止try語句塊的方式有
  // 1. 正常終止，執(zhí)行完語句塊最后一條語句
  // 2. 通過break/continue/return語句終止
  // 3. 拋出一個異常，異常被catch從句捕獲
  // 4. 拋出一個異常，異常未被捕獲，繼續(xù)向上傳播
}

其它語句類型

js最后還有三種語句類型：with,debugger 和use strict

with語句

之前講解全局變量時了解過一些作用域鏈的問題，with語句就是用來臨時擴展作用域鏈。語法如下：

with(object)
statement

這條語句將object添加到作用域鏈頭部，然后執(zhí)行statement，最后把作用域鏈恢復到原始狀態(tài)

在嚴格模式下禁止使用with語句，非嚴格模式，不推薦使用with語句。使用with語句js非常難以優(yōu)化，盡可能避免使用with語句

在對象嵌套層次很深的時候，通常使用with語句來簡化代碼編寫。例如下面這個栗子：

document.forms[0].address.value

如果這樣的代碼多次出現(xiàn)，則可以使用with語句將form對象添加到作用域鏈頂層：

with(document.forms[0]){
  // 直接訪問表單元素
  name.value = "";
  address.value = "";
  email.value = "";
}

這樣就減少大量的輸入，不用再為每個屬性名添加documents.forms[0]前綴。這個對象臨時掛載在作用域鏈上，
當js需要解析如address的標示符時，就會自動在這個對象中查找。當然不使用with的等價代碼形式：

var f = document.forms[0];
f.name.value = '';
f.address.value = '';
f.email.value = '';

需要注意的是，只有查找標示符時，才會用到作用域鏈，創(chuàng)建新的變量時候，不使用它.

看看這段代碼:

with(o) x=1;

如果對象o有一個屬性x，那么這行代碼給這個屬性賦值為1。但是如果o中沒有這個屬性x，這段代碼和不使用with的代碼
x = 1;是一樣的。它給一個或全局變量x賦值，或者創(chuàng)建全局變量的新屬性x。

簡單來說，就是with提供來讀取o屬性的快捷方式，但是不能創(chuàng)建o的屬性

debugger語句

程序員經(jīng)常需要打一些斷點來查看程序是否在按照自己設計正確運行，debugger語句就是讓js解釋器以調(diào)試模式
運行，來產(chǎn)生一個斷點，js執(zhí)行到斷點位置，停止運行，這時可以使用調(diào)試器輸出變量的值，檢查程序調(diào)用棧等等。

在ECMAScript5中，debugger語句正式加入語言，并且已經(jīng)得到主流瀏覽器廠商的支持。

debugger語句不會啟動調(diào)試器，但如果調(diào)試器已經(jīng)在運行，這條語句才會真正產(chǎn)生一個斷點，例如在使用Chrome開發(fā)者工具
中的命令行時，debugger語句才會正常工作

"use strict"

"use strict" 是ECMAScript5中引入的一條指令。

指令并不是語句，指令和語句有2個重要的區(qū)別：

• 語句不包含任何語言的關(guān)鍵字，指令僅僅包含一個特殊字符串直接量表達式，對于沒有實現(xiàn)ECMAScript5的js解釋器來說，只是一條沒有副作用的表達式語句，什么都沒執(zhí)行
• 只能出現(xiàn)在腳本代碼的開始或者函數(shù)體的開始、任何實體語句之前。在腳本或者函數(shù)體內(nèi)第一條常規(guī)語句之后的字符串直接量表達式語句只當作普通的表達式語句對待，不會被當作指令解析

使用"use strict"指令的目的是說明，后續(xù)的代碼將被解析成嚴格代碼。

嚴格代碼以嚴格模式執(zhí)行。ECMAScript5的嚴格表達式是該語言的受限的子集，修正語言的重要缺陷，并且提供健壯的查錯功能和增強的安全機制

嚴格模式和非嚴格模式區(qū)別如下:(前3條非常重要)

• 在嚴格模式中禁止使用with語句
• 所有的變量都需要先聲明，如果給一個未聲明的變量、函數(shù)、函數(shù)參數(shù)、catch從句參數(shù)或全局變量的對象賦值，將會拋出一個引用錯誤異常（非嚴格模式，這種隱式聲明的全局變量的方法是給全局對象新添加一個新屬性）
• 調(diào)用的函數(shù)（不是方法）中一個this值是undefined。（在非嚴格模式中，調(diào)用的函數(shù)中的this值總是全局對象。可以利用這種特性來判斷js實現(xiàn)是否支持嚴格模式

var hasStrictMode = (function(){ "use strict"; return this===undefined;});

• 在嚴格模式中，通過call()或apply()來調(diào)用函數(shù)時，其中的this值就是通過call()或apply()傳入的第一個參數(shù)（非嚴格模式中，null和undefined值被全局對象和轉(zhuǎn)換為對象的非對象值所代替）
• 在嚴格模式中，給只讀屬性賦值和給不可擴展的對象創(chuàng)建新成員都將拋出一個類型錯誤異常(非嚴格模式，這些操作只是簡單的失敗，不會報錯)
• 在嚴格模式中，傳入eval()的代碼不能調(diào)用程序所在的上下文中聲明變量或定義函數(shù)，而在非嚴格模式可以的。相反，變量和函數(shù)的定義是在eval()的新作用域中，這個作用域在eval()返回時就被棄用了
• 在嚴格模式中，函數(shù)的arguments對象擁有傳入函數(shù)值的靜態(tài)副本。而非嚴格模式，arguments對象具有魔術(shù)般行為，arguments里的數(shù)組和函數(shù)參數(shù)都是指向同一個值的引用
• 在嚴格模式中，當delete運算符后跟隨非法的標示符時，將會拋出一個語法錯誤異常（非嚴格模式，這種delete表達式將什么都不會做，并返回false）
• 在嚴格模式中，試圖刪除一個不可配置的屬性將拋出一個類型錯誤異常（非嚴格模式，這種delete表達式操作失敗，并返回false）
• 在嚴格模式中，在一個對象直接量中定義兩個或多個同名屬性將產(chǎn)生一個語法錯誤（非嚴格模式中不會報錯）
• 在嚴格模式中，函數(shù)聲明中存在兩個或多個同名參數(shù)將會產(chǎn)生一個語法錯誤（在非嚴格模式中不會報錯）
• 在嚴格模式中，不允許使用八進制數(shù)直接量（以0為前綴，非嚴格模式中某些實現(xiàn)是允許八進制數(shù)直接量的）
• 在嚴格模式中，標示符eval和arguments當作關(guān)鍵字，他們的值是不能更改的。不能給這些標識符賦值，也不能把它們聲明為變量、用作函數(shù)名、用作函數(shù)參數(shù)或者catch塊的標識符
• 在嚴格模式中，限制了對調(diào)用棧的監(jiān)測能力，arguments.caller和arguments.callee都會拋出一個類型錯誤異常。在嚴格模式的函數(shù)同樣有caller和arguments屬性，當訪問這兩個屬性值都將拋出類型錯誤異常

js語句總結(jié)表