在 JavaScript 中,表達式(expression)就像一個「短語」,直譯器會將它計算出一個結果。最簡單的表達式莫過於變量,變量名本身就是一種表達式,其值即為賦予該變量的值。而複雜的表達式則由簡單表達式透過運算子組合而成。本文將系統性地講解 JavaScript 中的各類表達式與運算子。
最簡單的表達式是「原始表達式」,它是表達式的最小單位,不包含其他表達式。JavaScript 的原始表達式包含常數(直接量)、關鍵字與變量。
直接量是直接出現在程式中的常數值:
1.23 // 數字直接量 "hello" // 字串直接量 /pattern/ // 正則表達式直接量
部分保留字也構成原始表達式:
true // 布林值:真 false // 假 null // 回傳一個值:空 this // 回傳「當前」物件
其中 this 並非常量,它在程式不同位置回傳的值也不同,常出現於物件導向程式設計中,用來指代目前方法的宿主物件。此外,變量也是一種原始表達式:
i // 回傳變量 i 的值 undefined // 全域變量,與 null 不同,它不是關鍵字
物件與陣列的初始化表達式用於建立新物件與新陣列,也常被稱為「物件直接量」與「陣列直接量」。由於它們的成員或元素本身也是子表達式,因此並非原始表達式。
陣列初始化表達式由一對中括號與內部以逗號分隔的清單構成:
[] // 空陣列 [1+2, 3+4] // 兩個元素的陣列,第一個是 3,第二個是 7 var mat = [[1,2,3],[4,5,6],[7,8,9]]; // 表達式可嵌套 var a = [1,,,,5]; // 中間空位會填充 undefined
物件初始化表達式與陣列類似,只是把中括號換成了大括號,並以冒號連接屬性名與值:
var p = {x: 2.1, y: -3} // 擁有兩個屬性成員的物件
var q = {}; // 空物件
q.x = 2.1; q.y = -3; // q 的屬性與 p 相同
var side = 1;
var square = {"left":{x:p.x,y:p.y},
'right':{x:p.x+side,y:p.y+side}}
函式定義表達式用來定義一個 JavaScript 函式,表達式的值即這個新定義的函式,因此也常被稱為「函式直接量」:
var square = function(x){ return x * x; };
屬性訪問表達式用來取得物件屬性或陣列元素的值,JavaScript 提供兩種寫法:
expression . identifier expression [expression]
o.x // 表達式 o 的 x 屬性 o.y.z // 表達式 o.y 的 z 屬性 o["x"] // 物件 o 的 x 屬性 a[1] // 表達式 a 索引為 1 的元素 a[2]["1"] // 表達式 a[2] 中索引為 1 的元素 a[0].x // 表達式 a[0] 的 x 屬性
無論使用哪種形式,位於「.」和「[」之前的表達式都會先被計算。若結果為 null 或 undefined,會拋出型別錯誤。雖然 .identifier 寫法更簡潔,但它僅適用於屬性名是合法識別字的情況;若屬性名是保留字、含空格標點、是數字,或是透過運算得出的動態值,就必須使用方括號寫法。
呼叫表達式(invocation expression)是呼叫或執行函式、方法的語法表示。它以一个函式表達式開頭,後接一對圓括號與逗號分隔的參數清單:
f(0) // f 是函式表達式,0 是參數 Math.max(x,y,z) // Math.max 是函式,x、y、z 是參數 a.sort() // 無參數的函式呼叫
求值時,會先計算函式表達式,再計算參數表達式,若函式表達式的值不是可呼叫的物件,則拋出型別錯誤。若函式使用 return 回傳值,該值即為整個呼叫表達式的值,否則為 undefined。
若呼叫表達式左括號前是一個屬性訪問表達式,則此呼叫稱為方法呼叫(method invocation)。在方法呼叫中,作為屬性訪問主體的物件便會成為函式體內 this 的指向,這正是物件導向程式設計的基礎。
物件建立表達式(object creation expression)會建立一個物件,並呼叫一個函式(建構函式)來初始化其屬性。它與函式呼叫表達式類似,只是前面多了一個 new 關鍵字:
new Object() new Point(2,3) new Object // 若不傳參數,圓括號可省略 new Point
JavaScript 的運算子用於算術、比較、邏輯與賦值等運算。運算子優先級由下表由高到低排列,同一水平線內的運算子優先級相同。
· A 表示結合性:L 為由左至右,R 為由右至左
· N 表示運算元個數
· 類型 表示期望的運算元類型與結果類型
運算元個數:JavaScript 大多數運算子是二元運算子(如加法);也支援一元運算子(如 -x 中的負號);並有一個三元運算子——條件運算子 ?:。
左值:賦值運算子等少數運算子要求其運算元為 lval(左值),即「只能出現在賦值運算子左側的表達式」。JavaScript 中,變量、物件屬性與陣列元素都是左值。
優先級:運算子優先級決定運算順序。例如:
w = x + y * z; // 乘法先於加法,加法先於賦值 w = (x + y) * z; // 用括號改變運算順序
需注意的是,屬性訪問與呼叫表達式的優先級比所有運算子都高。若不確定優先級,最簡單的方式就是用括號明確指定運算次序。
結合性:多個同優先級運算子並存時,結合性決定運算方向。減法為左結合:
w = x - y - z; // 等同於 w = ((x - y) - z)
而一元運算子、賦值與三元條件運算子為右結合:
w = x = y = z; // 等同於 w = (x = (y = z)) q = a ? b : c ? d : e ? f : g; // 等同於 a ? b : (c ? d : (e ? f : g))
運算順序:優先級與結合性規定了運算次序,但 JavaScript 總是嚴格地由左至右計算各子表達式。
基本算術運算子為 * / % + -。除法方面,由於 JavaScript 所有數字都是浮點數,5/2 的結果是 2.5 而非 2;除數為 0 時結果為正/負無窮大,0/0 則為 NaN。求餘運算子 % 計算被除數除以除數的餘數,結果符號與被除數一致(如 -5 % 2 為 -1)。
「+」運算子:加法運算子既能做數字加法,也能做字串連接:
1 + 2 // 3
"1" + "2" // "12"
"1" + 2 // "12",數字轉為字串後連接
1 + {} // "1[object object]"
true + true // 2,布林值轉為數字後相加
2 + null // 2,null 轉為 0
2 + undefined // NaN,undefined 轉為 NaN
加法運算的行為取決於類型轉換結果:若其中一個運算元是字串,另一個也轉為字串並進行連接;否則兩者都轉為數字後相加。特別要注意運算順序的影響:
1 + 2 + "bmice" // "3 bmice" 1 + (2 + "bmice") // "12bmice"
一元運算子:一元加法 + 把運算元轉為數字;一元減法 - 轉為數字後改變符號。遞增 ++ 與遞減 -- 會將運算元轉為數字後加減 1 並重新賦值:
var i = 1, j = ++i; // 前增量:i 和 j 都是 2 var i = 1, j = i++; // 後增量:i 是 2,j 是 1
注意 ++x 從不做字串連接,若 x 是字串 "1",++x 得到數字 2,而 x+1 得到字串 "11"。
關系運算子用於測試兩個值之間的關係,並回傳布林值,常用於 if、while、for 等流程控制語句中。
相等與不等運算子:===(嚴格相等)比較時不做任何類型轉換,==(相等)則會進行類型轉換。為減少混淆,建議把 = 稱作「賦值」、== 稱作「相等」、=== 稱作「嚴格相等」。
物件比較是引用比較而非值比較——即使兩個物件屬性完全相同,只要不是同一個物件就不相等。=== 的比較規則為:類型不同則不相等;兩值皆為 null 或 undefined 則不相等;NaN 與任何值(含自身)都不相等;+0 與 -0 相等。
== 在類型不同時會嘗試轉換:null 與 undefined 相等;數字與字串比較時字串轉數字;布林值 true 轉 1、false 轉 0;物件與數字或字串比較時,物件透過 valueOf() 或 toString() 轉為原始值。例如 "1" == true 結果為 true。
比較運算子:小於 <、小於等於 <=、大於 >、大於等於 >= 只能用於數字與字串。比較運算子偏向數字,只有兩個運算元都是字串時才進行字串比較:
11 < 3 // 數字比較,false "11" < "3" // 字串比較,false("1" 的編碼小於 "3") "11" < 3 // 數字比較,"11" 轉為 11,false "one" < 3 // "one" 轉為 NaN,false
in 運算子:左運算元為屬性名,右運算元為物件,若右側物件擁有該屬性則回傳 true:
var point = {x: 1, y: 1};
"x" in point // true
"z" in point // false
"toString" in point // true,繼承了 toString 方法
instanceof 運算子:左運算元為物件,右運算元為建構函式,若左側物件是右側類別的實例則回傳 true:
var d = new Date(); d instanceof Date; // true d instanceof Object; // true,所有物件都是 Object 的實例 d instanceof Number; // false var a = [1,2,3]; a instanceof Array; // true a instanceof RegExp; // false
其原理是:JavaScript 先計算 f.prototype,再在 o 的原型鏈中查找,若找到則 o 是 f(或其父類)的實例。
邏輯與 &&:可從三個層次理解。第一層,兩運算元皆為布林值時執行 AND 運算。第二層,它對真值與假值進行 AND 運算。第三層(最實用):它先計算左運算元,若為假值則直接回傳左值,不再計算右側表達式,這稱為「短路」(short circuiting):
var o = {x: 1};
var p = null;
o && o.x; // 1,o 是真值,回傳 o.x
p && p.x // null,p 是假值,直接回傳,不計算 p.x(否則會報錯)
利用短路特性可條件式執行程式碼:
if (a == b) stop(); // 只有 a==b 時才呼叫 stop() (a == b) && stop(); // 等價寫法
邏輯或 ||:先計算左運算元,若為真值則回傳,否則計算右側。常用來從多個備選表達式中選取第一個真值,或為參數提供預設值:
var max = max_width || preferences.max_width || 500;
function copy(o, p) {
p = p || {}; // 若未傳入 p,則使用新物件
}
邏輯非 !:一元運算子,先將運算元轉為布林值再求反,總是回傳 true 或 false。連續使用兩次可得到布林值 !!x。它也遵守德摩根定律:
!(p && q) === !p || !q !(p || q) === !p && !q
JavaScript 使用 = 為變量或屬性賦值。賦值表達式的值即右運算元的值,且結合性為由右至左,因此可以連續賦值:
i = 0 // 將變量 i 設為 0 o.x = 1 // 將物件 o 的屬性 x 設為 1 i = j = k = 0; // 三個變量初始化為 0
此外還有一類「帶運算的賦值運算子」,例如 += 同時執行加法與賦值:
total += sales_tax; // 等價於 total = total + sales_tax
此類運算子還包括 -= *= /= %= <<= >>= >>>= &= |= ^= 等。一般來說 a op= b 等價於 a = a op b,但當 a 含副作用表達式時兩者並不等價:
data[i++] *= 2; // i 只遞增一次 data[i++] = data[i++] * 2; // i 遞增兩次,不等價
與多數直譯語言一樣,JavaScript 可透過全域函式 eval() 執行由原始碼組成的字串:
eval("3+2") // 5
eval() 只有一個參數,若參數不是字串則直接回傳。若是字串,它會將字串當作 JavaScript 編譯執行,並回傳最後一個表達式或語句的值。eval() 最關鍵的特性是:它使用呼叫它的變量作用域環境,因此能讀寫、定義局部變量與函式。
全域 eval:當透過別名間接呼叫時,eval() 會將字串當成頂層全域程式碼執行,無法修改主函式中的局部變量,因此不會影響函式內程式碼的優化:
var geval = eval; // 透過別名呼叫將是全域 eval
var x = "global", y = "global";
function f() {
var x = "local";
eval("x += 'changed';"); // 直接 eval 改變了局部變量
return x; // 回傳 "local changed"
}
function g() {
var y = "local";
geval("y += 'changed';"); // 間接 eval 改變的是全域變量
return y; // 回傳未更改的 "local"
}
條件運算子 ?::JavaScript 中唯一的三元運算子,可視為 if 語句的簡寫:
greeting = "hello" + (username ? username : "three"); x > 0 ? x : -x; // 求 x 的絕對值
typeof 運算子:一元運算子,回傳表示運算元類型的字串:
typeof undefined // "undefined"
typeof null // "object"
typeof true // "boolean"
typeof 42 // "number"
typeof "str" // "string"
typeof function(){} // "function"
typeof {} // "object"
delete 運算子:一元運算子,用來刪除物件屬性或陣列元素,具有副作用:
var o = {x: 1, y: 2};
delete o.x; // true,屬性被刪除
"x" in o; // false
var a = [1, 2, 3];
delete a[2]; // 刪除最後一個元素,但留下「洞」
a.length; // 3,長度並未改變
注意 delete 刪除屬性後,該屬性不復存在(而非設為 undefined)。它不能刪除透過 var 宣告的變量。
void 運算子:一元運算子,運算元照常計算,但忽略結果並回傳 undefined,常用於超連結中避免瀏覽器顯示運算結果:
<a href="javascript:void window.open();">new</a>
逗號運算子 ,:二元運算子,先計算左運算元再計算右運算元,回傳右側結果,常用於 for 迴圈中處理多個迴圈變量:
for (var i = 0, j = 10; i < j; i++, j--); console.log(i + j);