本文整理自 JavaScript 核心讀書筆記,系統性地梳理了運算式(expression)與運算子(operator)的相關知識。
運算式是 JavaScript 中的一個「片語」,解譯器會將它計算出一個結果。最簡單的一類運算式就是變數——變數名本身也是一種簡單運算式,其值就是賦給變數的值。複雜的運算式則由簡單運算式組成,而把它們組合成複雜運算式最常用的方法就是運算子。
最簡單的運算式是「原始運算式(primary expression)」,它是最小的單位,不包含其他運算式。JavaScript 中的原始運算式包含常量(直接量)、關鍵字與變數。
直接量是直接出現在程式中的常量值:
1.23 // 數字直接量 "hello" // 字串直接量 /pattern/ // 正則表達式直接量
一些保留字也構成原始運算式:
true // 布林值:真 false // 假 null // 回傳一個值:空 this // 回傳「當前」物件
與其他關鍵字不同,this 並不是常量,它在程式不同位置回傳的值也不同,常用於物件導向程式設計中,回傳所呼叫方法的物件。第三種原始運算式是變數:
i // 回傳變數 i 的值 sum // 回傳 sum 的值 undefined // 全域變數,與 null 不同,它不是關鍵字
物件與陣列初始化實際上是建立新的物件與陣列,這些初始化運算式有時稱為「物件直接量」與「陣列直接量」。但它們不是原始運算式,因為所包含的成員或元素都是子運算式。
陣列初始化運算式以一方括號與其內以逗號隔開的列表構成,結果是一個新建立的陣列:
[] // 一個空陣列 [1+2, 3+4] // 有兩個元素的陣列,第一個是 3,第二個是 7
陣列初始化運算式中的元素可以是另一個陣列初始化運算式,也就是運算式可以嵌套:
var mat = [[1,2,3],[4,5,6],[7,8,9]];
陣列直接量中的元素之間可以省略,空位會填入 undefined:
var a = [1,,,,5] // 其中 4 個元素是 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 函式,其值就是這個新定義的函式。一個典型的函式定義運算式包含關鍵字 function,其後是一對圓括號(括號內是以逗號分隔的參數名列表),再加上以花括號包裹的函式體:
var square = function(x){ return x * x; };
函式定義運算式同樣可以包含函式名,也可透過函式語句來定義。
屬性存取運算式運算得到一個物件或一個陣列元素的值,JavaScript 定義了兩種寫法:
expression . identifier expression [expression]
第一種寫法是運算式後接句點與標識符;第二種使用方括號,括號內的運算式指定要存取的屬性名或陣列元素索引:
o.x // => 1,運算式 o 的 x 屬性 o.y.z // => 3,運算式 o.y 的 z 屬性 o["x"] // => 1,物件 o 的 x 屬性 a[1] // => 4,運算式 a 索引為 1 的元素 a[2]["1"] // => 6,運算式 a[2] 中索引為 1 的元素 a[0].x // => 1,運算式 a[0] 的 x 屬性
無論使用哪一種形式,在「.」與「[」之前的運算式總會先被計算。若結果為 null 或 undefined,會拋出型別錯誤,因為這兩者不能包含任何屬性。若屬性名是保留字、含空格或標點、或透過運算得出,就必須使用方括號寫法。
呼叫運算式(invocation expression)是一種呼叫(執行)函式或方法的語法。它以一个函式運算式開始,後接一對圓括號,括號內是以逗號隔開的參數列表:
f(0) // f 是函式運算式;0 是參數運算式 Math.max(x, y, z) // Math.max 是函式;x、y、z 是參數 a.sort() // a.sort() 是函式,沒有參數
求值時,先計算函式運算式,再計算參數運算式得到一組參數值。若函式運算式的值不是可呼叫的物件,則拋出型別錯誤。接著參數值依序賦給形參並執行函式體;若有 return 則回傳該值,否則回傳 undefined。
若呼叫運算式中括號前的運算式是一個屬性存取運算式,則稱之為「方法呼叫(method invocation)」。此時函式體內 this 的指向即為該屬性存取的宿主物件,這正是物件導向典範的基礎。
物件建立運算式(object creation expression)建立一個物件並呼叫一個函式(構造函式)來初始化其屬性,寫法與函式呼叫類似,只是前面多了一個 new 關鍵字:
new Object() new Point(2, 3)
若不需傳入參數,圓括號可省略:
new Object new Point
JavaScript 的運算子用於算術、比較、邏輯與賦值等運算。多數運算子以標點符號表示,也有以關鍵字表示的(如 delete、instanceof)。運算子依優先級排序,被水平線隔開的運算子具有不同優先級;A 欄表示結合性(L 從左至右、R 從右至左),N 欄表示操作數個數,類型欄表示期望的操作數類型與結果類型(→ 之後)。
JavaScript 大多數運算子是二元運算子,將兩個運算式合併為一個較複雜的運算式;也支援一些一元運算子(如 -x 中的「-」);並支援唯一的三元運算子——條件運算子「?:」。
一些運算子可用於任何資料型別,但仍期望操作指定類型的資料。
賦值運算子與少數運算子期望其操作數為 lval 類型。「左值」是古老術語,指「只能出現在賦值運算子左側的運算式」。在 JavaScript 中,變數、物件屬性與陣列元素都是左值。
優先級控制運算子的執行順序,優先級高者先執行。例如在 w = x + y * z 中,乘法優先級高於加法,故先執行乘法;賦值運算子優先級最低,最後執行。若真的不確定優先級,最簡單的方法就是用圓括號強行指定運算次序。需牢記:乘除高於加減,賦值優先級非常低。此外,屬性存取與呼叫運算式的優先級比所有運算子都高。
結合性決定了多個同優先級運算子的運算順序。減法由左到右結合:
w = x - y - z // 等同 w = ((x - y) - z)
而一元運算子、賦值與三元條件運算子則是從右至左結合:
x = ~-y; // 等同 x = ~(-y) w = x = y = z; // 等同 w = (x = (y = z)) q = a ? b : c ? d : e ? f : g; // 等同 q = a ? b : (c ? d : (e ? f : g))
運算子的優先級與結合性規定了運算順序,但並未規定子運算式的計算順序。JavaScript 總是嚴格從左至右計算運算式。
基本算術運算子是 *、/、%、+、-。除了加法外,其餘運算子只是在必要時將操作數轉為數字,再求積、商、餘與差;無法轉為數字者會轉為 NaN。JavaScript 所有數字皆為浮點數,故 5/2 結果為 2.5 而非 2;除數為 0 時結果為正或負無窮大,0/0 則為 NaN,且不會報錯。% 運算子計算餘數,結果符號與被除數一致,例如 5%2 為 1、-5%2 為 -1。
二元加法運算子「+」可做數字加法,也可做字串連接:
1 + 2 // => 3 "hello" + "" + "there" // => "hello there" "1" + "2" // => "12"
加法運算子的行為依型別轉換結果而定:若一個操作數是物件,會先轉為原始值(日期用 toString(),其他物件優先用 valueOf(),多半退回 toString());轉換後若其中一個是字串,另一個也轉為字串並進行連接;否則兩者都轉為數字後相加。
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" // => "3bmice" 1 + (2 + "bmice") // => "12bmice"
一元運算子作用於單一操作數並產生新值,優先級很高且為右結合。
一元加法 +:把操作數轉為數字(或 NaN)並回傳。
一元減法 -:把操作數轉為數字後改變其符號。
遞增 ++:對操作數(須為左值)加 1 並重新賦值。前增量(++i)回傳計算後的值,後增量(i++)回傳未計算前的值:
var i = 1, j = ++i; // i 和 j 都是 2 var i = 1, j = i++; // i 是 2,j 是 1
注意 ++x 與 x = x + 1 並不完全相同——++ 從不做字串連接,它總會把操作數轉為數字再加 1。遞減 -- 方式相同,只是減 1。
位運算子對數字的二進位表示進行按位運算,因為作用於數值並回傳數字,這裡歸類為算術運算子。它們在 JavaScript 中不常見。
關聯運算子用於測試兩個值之間的關係(相等、小於、「是…的屬性」),依關係是否存在而回傳 true 或 false。關聯運算式總是回傳布林值,常用於 if、while、for 等語句以控制流程。
「===」是嚴格相等運算子(恆等運算子),比較時不做任何型別轉換;「==」是相等運算子,比較時允許型別轉換。「!=」與「!==」則分別是它們的求反。
嚴格相等「===」的規則:型別不同則不相等;兩者皆為 null 或 undefined 則相等;皆為相同布林值則相等;任一為 NaN 則不相等(NaN 與任何值都不等,含自身);數字相等(0 與 -0 相等)則相等;字串需對應位 16 位值完全相同才相等;兩個參照指向同一物件才相等。
相等運算子「==」在型別不同時會嘗試轉換:null 與 undefined 相等;數字與字串先將字串轉數字;true 轉 1、false 轉 0;物件與數字或字串時先將物件轉原始值再比較;其他不同型別的比較皆不相等。
比較運算子(<、<=、>、>=)只有數字與字串能真正執行比較,其他型別會先轉為原始值。若兩者皆為字串,則依 16 位 Unicode 索引順序(字母表順序)比較;若至少一個不是字串,則兩者都轉為數字比較。任一操作數為 NaN 時,比較運算子總是回傳 false。
值得注意的是,加號偏愛字串(任一操作數為字串即連接),而比較運算子偏愛數字(只有兩者皆為字串才做字串比較):
1 + 2 // => 3 "1" + "2" // => "12" "1" + 2 // => "12" 11 < 3 // => false,數字比較 "11" < "3" // => false,字串比較 "11" < 3 // => false,"11" 轉 11 後比較 "one" < 3 // => false,"one" 轉 NaN
此外,「<=」與「>=」在判斷相等時並不依賴相等運算子的規則,而是分別等同「不大於」與「不小於」,唯一例外是當操作數為 NaN 時四個比較運算子皆回傳 false。
in 運算子期望左操作數為字串(或可轉字串)、右操作數為物件。若右側物件擁有一個名為左操作數值的屬性,則回傳 true:
var point = {x: 1, y: 1};
"x" in point // => true,物件有 x 屬性
"z" in point // => false,無 z 屬性
"toString" in point // => true,繼承了 toString 方法
var data = [7, 8, 8];
"0" in data // => true
1 in data // => true,數字轉字串
3 in data // => false,沒有索引為 3 的元素
instanceof 運算子期望左操作數為物件、右操作數標示物件的類。若左側物件是右側類的實例則回傳 true:
var d = new Date(); d instanceof Date; // => true,d 由 Date() 建立 d instanceof Object; // => true,所有物件都是 Object 的實例 d instanceof Number; // => false var a = [1, 2, 3]; a instanceof Array; // => true a instanceof Object; // => true,所有陣列都是物件 a instanceof RegExp; // => false
計算 o instanceof f 時,JavaScript 會先算出 f.prototype,再到 o 的原型鏈中查找,若找到則 o 是 f(或其父類)的實例,回傳 true,否則回傳 false。
邏輯運算子「&&」、「||」、「!」對操作數進行布林運算,常與關聯運算子搭配,將多個關聯運算式組合成更複雜的運算式。
「&&」可從三個層次理解:最簡單的一層是當操作數皆為布林值時執行布林與運算,只有兩者皆為 true 才回傳 true。第二層是它能對「真值」與「假值」做布林與運算。第三層最重要——它會短路(short circuiting):先計算左操作數,若為假值則直接回傳左值,不再計算右操作數。
var o = {x: 1};
var p = null;
o && o.x; // => 1,o 是真值,回傳 o.x
p && p.x; // => null,p 是假值,直接回傳而不計算 p.x
因此當右側運算式具有副作用(賦值、遞增、函式呼叫)時要格外小心,因為它是否執行取決於左操作數的結果。
「||」對兩個操作數做布林或運算。與「&&」類似,它也具備短路行為:先計算左操作數,若為真值則回傳,否則再計算右操作數。最常見的用法是從一組備選運算式中選取第一個真值,常用於提供參數預設值:
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 含有副作用運算式(如函式呼叫與賦值)時,兩者並不等價。
和許多解譯語言一樣,JavaScript 能透過全域函式 eval() 解譯執行由原始碼組成的字串並產生一個值:
eval("3+2"); // => 5
eval() 只有一個參數:若非字串則直接回傳該參數;若是字串則編譯執行,回傳最後一個運算式或語句的值(無值則回傳 undefined),編譯失敗則拋出語法錯誤。
關於 eval() 最重要的是,它使用呼叫它的變數作用域環境,因此能讀寫、定義局部變數與函式。
由於 eval() 能改變局部變數,對 JavaScript 優化器是一大難題。ECMAScript 5 規範了 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"
}
console.log(f(), x); // local changed global
console.log(g(), y); // local global changed
條件運算子是 JavaScript 中唯一的三元運算子,有三個操作數。若第一個操作數(作為布林值)為真值,則計算並回傳第二個;否則計算並回傳第三個。第二與第三個操作數必會計算其一:
x > 0 ? x : -x; // 求 x 的絕對值 grett = "hello" + (username ? username : "guest");
typeof 是一元運算子,回傳表示操作數類型的一個字串:
undefined => "undefined" null => "object" true 或 false => "boolean" 任意數字或 NaN => "number" 任意字串 => "string" 任意函式 => "function" 任意物件(非函式) => "object"
它常寫在運算式中,也可加上圓括號讓它看起來像函式:
(typeof value == "string") ? "" + value + "" : value; typeof(i)
delete 是一元運算子,用來刪除物件的屬性或陣列的元素,具有副作用:
var o = {x: 1, y: 2};
delete o.x; // 刪除 o 的 x 屬性
"x" in o; // => false
var a = [1, 2, 3];
delete a[2]; // 刪除陣列最後一個元素
2 in a; // => false,元素 2 已不存在
a.length; // => 3,陣列長度不變,只是留下一個「洞」
刪除屬性不只是設為 undefined,而是讓該屬性不復存在。delete 也有嚴格模式下的相關限制:
var o = {x: 1, y: 2};
delete o.x; // 刪除物件屬性,回傳 true
delete o.x; // 刪除不存在的屬性,回傳 true
delete o; // 無法刪除以 var 宣告的變數,回傳 false
delete 1; // 參數不是左值
this.x = 1; // 為全域定義一個屬性(未使用 var)
delete x; // 非嚴格模式回傳 true;嚴格模式會拋出異常,此時應改用 delete this.x
void 是一元運算子,操作數會照常計算,但忽略結果並回傳 undefined。因此當操作數具有副作用時使用 void 才有意義,最常用於帶客戶端的 URL,讓瀏覽器不顯示運算結果:
<a href="javascript:void window.open();">new</a>
逗號運算子是二元運算子,先計算左操作數再計算右操作數,並回傳右操作數的值。左側運算式的計算結果會被忽略,因此只有當左側具有副作用時才有意義。它最常用於 for 迴圈中有多個迴圈變數的情況:
i = 0, j = 1, k = 2; // for 迴圈中的第一個逗號是 var 語句的一部分 // 第二個逗號是逗號運算子,將 i++ 和 j++ 放在同一條語句中 for (var i = 0, j = 10; i < j; i++, j--); console.log(i + j);
以上就是 JavaScript 運算式與運算子的完整梳理,掌握這些規則,就能讀懂並寫出語意清晰的程式碼。