如果說表達式是 JavaScript 裡的「片語」,那麼語句(statement)就是完整的句子或指令。英文句子以句號收尾,JavaScript 則以分號作結。表達式的結果是一個值,語句則是「讓某件事真的發生」。理解語句的種類與規則,等於掌握了程式碼的骨架。
讓事情發生的方式之一,是執行帶有副作用的表達式。賦值與函式呼叫正是典型例子,把它們單獨寫成一行,就稱為表達式語句。
greet = "hello" + name; i *= 3; counter++; delete o.x; alert(greet); window.close();
遞增、遞減運算子本質上也是賦值;delete 則用來移除物件屬性或陣列元素。至於 Math.cos(x) 這種沒有副作用的呼叫,單獨寫成一行毫無意義,通常要把它賦值給變數才有用:
var cx = Math.cos(x);
另一類是宣告語句,也就是 var 與 function,它們本身不執行運算,但透過建立變數與函式來組織程式碼的語意。
用逗號運算子能把多個表達式串成一個表達式;用大括號則能把多條語句打包成複合語句(也稱語句區塊),在需要「只寫一條語句」的位置一次放入多行程式:
{
x = Math.PI;
cx = Math.cos(x);
console.log("cos(π)=" + cx);
}
關於語句區塊有三點要記住:區塊本身不需要分號結尾,但裡面的每條語句要;縮排雖非強制,卻直接影響可讀性;JavaScript 沒有區塊級作用域,在區塊內用 var 宣告的變數並不屬於該區塊私有。
與複合語句相反的極端是空語句,它一條語句都不含,就是一個孤零零的分號:
;
空語句看著無用,在設計「循環體為空」的迴圈時卻很好用:
// 初始化陣列 a for (i = 0; i < a.length; a[i++] = 0);
所有工作都在表達式 a[i++] = 0 裡完成,但語法要求循環體至少有一條語句,於是用一個分號充數。也正因為空語句太不明顯,它經常釀成難以追查的 bug:
if ((a == 0) || (b == 0)); // 這行什麼也沒做 o = null; // 這行則永遠會執行
如果確實需要空語句,強烈建議加上註解說明意圖:
for (i = 0; i < a.length; a[i++] = 0) /*empty*/;
var 用來宣告一個或多個變數,每個都可以帶初始值:
var i; // 單純宣告 var j = 0; // 帶初始值 var p, q; // 一次宣告兩個 var x = 2.34, y = Math.cos(0.75), r, theta; var x = 2, y = x * x; // 後者可用到前者
在函式體內宣告的是區域變數,作用域為該函式;寫在最外層則是全域變數,等於全域物件的屬性。值得注意的是,var 宣告出來的全域變數無法用 delete 刪除。若宣告時沒給初始值,變數值為 undefined。重複宣告同一個變數不會報錯,也不會有額外效果。
function 則用來宣告函式,語法如下:
function funcname([arg1[, arg2[, ..., argn]]]) {
statements
}
與 while 等語句的區塊不同,函式定義的大括號是必須的,即使函式體只有一條語句也不能省。
function hyteus(x, y) {
return Math.sqrt(x * x + y * y);
}
hyteus(1, 2); // => 2.23606797749979
function facial(n) { // 遞迴函式
if (n <= 1) return 1;
return n * facial(n - 1);
}
facial(11); // => 39916800
函式宣告通常寫在程式碼最前面,也可以巢狀,但巢狀時只能放在外層函式的頂部,不能寫在 if、while 或其他語句裡面。函式宣告建立的變數不可刪除,但值可以被覆寫。
條件語句是程式碼的「決策點」,相當於路上的岔口。
if (expression) statement if (username == null) username = "jack wong";
括住 expression 的圓括號是必須的。若要多執行幾條語句,用大括號包成語句區塊即可。加上 else 就是兩條分支:
if (n == 1)
console.log("1 new message");
else
console.log("you have " + n + " new message");
巢狀使用時要特別小心 else 的歸屬,因為 JavaScript 的規則是「else 一律配對最近的 if」,縮排只是給人看的,並不影響語意:
if (i == j)
if (j == k)
console.log("i equs k");
else
console.log("i dosent equal j"); // 錯誤!else 配到外層了
正確且好維護的寫法是加上大括號:
if (i == j) {
if (j == k) {
console.log("i equs k");
} else {
console.log("i dosent equal j");
}
}
許多開發者習慣即使只有一條語句也補上大括號,正是為了徹底避開這個歧義。
else if 並不是獨立的語句,而是多組 if/else 串接的寫法:
if (n == 1) {
// 執行區塊 1
} else if (n == 2) {
// 執行區塊 2
} else if (n == 3) {
// 執行區塊 3
} else {
// 以上皆不成立
}
當所有分支都在判斷同一個表達式的值時,switch 比連續的 else if 更合適,因為不必重複計算同一個式子。
switch (n) {
case 1: // n === 1 時由此進入
// 區塊 1
break;
case 2:
// 區塊 2
break;
case 3:
// 區塊 3
break;
default:
// 都不匹配時執行
break;
}
執行時先算出 switch 後表達式的值,再依序比對各個 case。比對用的是 ===,因此不會進行型別轉換。case 只標示了進入點,沒有標示結束點,若忘了 break,程式會一路往下執行到整個 switch 結束,這稱為落入(fall through)。在函式中也可以用 return 取代 break 達到同樣效果。
一個實戰例子是依型別轉字串:
function convert(x) {
switch (typeof x) {
case 'number':
return x.toString(16); // 數字轉 16 進位
case 'string':
return '"' + x + '"'; // 加上雙引號
default:
return String(x);
}
}
console.log(convert(100255114)); // => 5f9c58a
ECMAScript 標準允許 case 後接任意表達式,但由於並非每個 case 都會被求值,應避免在 case 中放帶副作用的表達式,最安全的做法是只使用常數。default 標籤寫在哪裡都合法,但放在最後最合理也最常見。
while (expression) statement
先判斷 expression,為真才執行循環體,為假則跳過。注意 while (true) 會形成無窮迴圈。實務上循環體內通常會有變數隨迭代改變,否則條件永遠為真:
var count = 0;
while (count < 10) {
console.log(count);
count++;
}
與 while 的差别在於條件判斷放在尾部,因此循環體至少執行一次:
do statement while (expression);
注意 do/while 以分號結尾;若循環體用大括號包起來,則不需要分號。
function printArray(a) {
var len = a.length, i = 0;
if (len == 0)
console.log("空陣列");
else
do {
console.log(a[i]);
} while (++i < len);
}
printArray([1, 5, 2, 6]);
for 把「初始化、條件判斷、更新計數」三件事明寫在語法裡,是計數型循環的首選:
for (initialize; test; increment) statement
它等價於:
initialize
while (test) {
statement
increment;
}
三個表達式用分號隔開,任一都可省略,但兩個分號不能省。省略 test 就是無窮迴圈,等價寫法還有 while (true) 與 for (;;)。
for (var count = 0; count < 10; count++)
console.log(count);
// 一次迭代多個變數,需借助逗號運算子
var i, j;
for (i = 0, j = 10; i < 10; i++, j--)
console.log(i * j);
// 循環變數不必是數字
function tail(o) { // 回傳鏈結串列的最後一個節點
for (; o.next; o = o.next) /*empty*/
return o;
}
for/in 用來遍歷物件的屬性名稱:
for (variable in object) statement
var o = {x: 1, y: 2, z: 3};
for (var p in o)
console.log(o[p]); // 依序輸出 1、2、3
執行時先算出 object 表達式,若為 null 或 undefined 則直接跳過循環;若是原始值會先轉為對應的包裝物件。接著每次迭代把屬性名(字串)賦給 variable。
要注意的是,for/in 只遍歷可枚舉的屬性。語言核心定義的內建方法(例如 toString)通常不可枚舉,因此不會被列出;而程式自行定義的屬性與方法一般都是可枚舉的。物件繼承來的自訂屬性也會被遍歷到。
此外,循環體中若刪除了尚未遍歷到的屬性,該屬性不會再出現;若新增屬性,則通常不會被遍歷(部分實作例外)。
至於枚舉順序,ECMAScript 規範並未明定。實作上主流瀏覽器多半依屬性定義的先後順序枚舉,用物件直接量建立時則依字面順序。但在以下情況,順序屬於實作相依,不可依賴:物件繼承了可枚舉屬性、具有整數索引屬性、用 delete 刪過屬性、或用 Object.defineProperty 改過屬性描述。
語句可以加上標籤,形式為「識別字加冒號」:
identifier: statement
mainloop: while (token != null) {
// 略
continue mainloop; // 直接跳到下一次迭代
// 略
}
標籤識別字必須是合法識別字但不能是保留字,其命名空間與變數、函式分離。break 與 continue 是 JavaScript 中唯一能搭配標籤使用的語句。
break; break labelname;
不帶標籤時,break 立即結束最內層的循環或 switch,因此只能用在這兩類語句中。當循環的终止條件很複雜時,在循環體內用 break 判斷往往比把條件全塞進迴圈表達式裡更清楚:
for (var i = 0; i < a.length; i++) {
if (a[i] == target) break;
}
帶標籤的 break 可以跳出任何被標籤標示的語句區塊,不限於循環與 switch:
var matrix = getData();
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;
}
}
success = true;
}
// break 會跳到這裡
關鍵細節:break 與標籤名之間不能換行,因為 JavaScript 的自動分號補全會在 break 後補上分號,導致標籤被忽略。另外,不論帶不帶標籤,break 都無法跨越函式邊界。
continue; continue labelname;
continue 不結束循環,而是結束「本次迭代」進入下一次,因此只能用在循環中。它在不同循環裡的行為略有差異:
正因為 for 會先跑 increment 而 while 不會,所以用 while 無法完美模擬 for 在 continue 上的行為。
for (i = 0; i < data.length; i++) {
if (!data[i]) continue; // 遇到空值就跳過這一筆
total += data[i];
}
和 break 一樣,continue 與標籤名之間也不能換行。
return expression;
return 只能出現在函式體內,執行到它就結束函式並把表達式的值交回呼叫方。若函式沒有 return,執行到函式結尾後會回傳 undefined。return 後也可以不帶表達式,效果同樣是回傳 undefined:
function square(x) { return x * x; }
square(4); // 16
// 參數不合法就提早結束
if (!o) return;
同樣地,return 與其後的表達式之間不能換行,理由也是自動分號補全。
throw expression;
異常是錯誤或異常狀態的信號。拋出異常就是發出這個信號,捕獲異常則是處理它。expression 可以是任何型別的值,實務上多拋 Error 物件或其子類,因為它自帶 name 與 message 屬性,除錯資訊更完整:
function fa(x) {
if (x < 0) throw new Error("x 不能是負數。");
for (var f = 1; x > 1; f *= x, x--) /*empty*/;
return f;
}
拋出後,解譯器會立即停止目前邏輯,沿著呼叫堆疊往上尋找最近的 catch 區塊;若一路都沒有對應的處理程序,最終會被當成程式錯誤回報給使用者。
這三個區塊組成 JavaScript 的異常處理機制。try 包住可能出錯的程式碼,catch 在真的拋出異常時接手,finally 則無論有無異常都會執行,通常用來放清理工作。catch 與 finally 都是可選的,但兩者至少要有一個;三個區塊的大括號都是必須的。
try {
// 可能拋出異常的程式碼
}
catch (e) {
// 僅在 try 拋出異常時執行
// e 是 catch 區塊內的區塊級作用域變數
}
finally {
// 無論是否有異常都會執行
}
catch 括號中的識別字看起來像函式參數,但它是區塊級作用域,只在 catch 區塊內有效,這是它與一般 var 變數的重要差別。
一個實戰例子:
try {
var n = Number(prompt("請輸入一個正整數", ""));
var f = factorial(n);
alert(n + "!=" + f);
} catch (ex) {
document.write(ex); // 讓使用者知道出了什麼問題
}
finally 的執行時機值得細究:只要 try 區塊開始執行過,無論它是正常跑完、被 break/continue/return 中斷,還是拋出並被 catch 接住、甚至拋出未被攔下而繼續往上傳播,finally 都會執行。
try {
print("Outer try running..");
try {
print("Nested try running...");
throw "an error";
} catch (e) {
print("Nested catch caught " + e);
throw e + " re-thrown";
} finally {
print("Nested finally is running...");
}
} catch (e) {
print("Outer catch caught " + e);
} finally {
print("Outer finally running");
}
輸出順序為:
Outer try running.. Nested try running... Nested catch caught an error Nested finally is running... Outer catch caught an error re-thrown Outer finally running
with (object) statement
with 會把指定物件暫時放到作用域鏈的最前端,執行完 statement 後再還原。它主要用在物件巢狀很深時簡化取值:
with (document.forms[0]) {
// 直接存取表單元素
name.value = "";
address.value = "";
email.value = "";
}
等價但不使用 with 的寫法:
var f = document.forms[0]; f.name.value = ""; f.adress.value = ""; f.email.value = "";
然而 with 有兩個嚴重問題:它讓引擎難以優化,效能明顯較差;程式碼中識別字的實際指向變得不明確,容易誤判。因此嚴格模式下直接禁用 with,非嚴格模式也強烈不建議使用。
還有一個容易誤解的地方:作用域鏈只用於查找識別字,不用於建立變數。
with (o) x = 1;
若 o 有 x 屬性,這行是給該屬性賦值;若 o 沒有 x,那這行與 x = 1 完全等價,也就是給區域或全域變數賦值。with 只提供讀取物件屬性的捷徑,並不會為該物件建立屬性。
debugger 語句本身不做任何事,但若除錯器正在運行,它會產生一個中斷點,讓程式碼執行停在該處,此時即可檢查變數值與呼叫堆疊:
function f(o) {
if (o === undefined) debugger; // 臨時用於除錯
console.log(1);
// 其餘邏輯
}
f();
要留意的是,debugger 不會主動啟動除錯器。必須先開啟開發者工具(例如 Firefox 的 Firebug),這行語句才會真正產生中斷效果。
嚴格模式指令有兩個不同於普通語句的特點:它不含任何關鍵字,只是一個由字串直接量構成的表達式;而且它必須出現在腳本開頭或函式體開頭,在任何實體語句之前。
其作用是宣告後續程式碼以嚴格模式解析。若寫在程式最外層,整個腳本都是嚴格程式碼;若寫在函式體開頭,則該函式為嚴格模式;若 eval 內含此指令,eval 中的程式碼也走嚴格模式。
嚴格模式是語言的受限子集,修正了不少歷史缺陷,主要差異包括:
可以用一段小程式偵測環境是否支援嚴格模式:
var hasStrictMode = (function () {
"use strict";
return this === undefined;
}());
把常用語句整理如下,方便對照回查:
掌握了這些語句,其實就已經具備讀寫 JavaScript 程式的基本能力了。剩下的是在實作中反覆驗證這些規則,尤其是自動分號補全與作用域這兩塊,多踩幾次就記得住了。