DIV CSS 佈局教程網

JavaScript 核心筆記:運算式與運算子全解
編輯:關於JavaScript     

本文整理自 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 欄表示操作數個數,類型欄表示期望的操作數類型與結果類型(→ 之後)。

i. 操作數的個數

JavaScript 大多數運算子是二元運算子,將兩個運算式合併為一個較複雜的運算式;也支援一些一元運算子(如 -x 中的「-」);並支援唯一的三元運算子——條件運算子「?:」。

ii. 操作數類型與結果類型

一些運算子可用於任何資料型別,但仍期望操作指定類型的資料。

iii. 左值

賦值運算子與少數運算子期望其操作數為 lval 類型。「左值」是古老術語,指「只能出現在賦值運算子左側的運算式」。在 JavaScript 中,變數、物件屬性與陣列元素都是左值。

iv. 運算子的優先級

優先級控制運算子的執行順序,優先級高者先執行。例如在 w = x + y * z 中,乘法優先級高於加法,故先執行乘法;賦值運算子優先級最低,最後執行。若真的不確定優先級,最簡單的方法就是用圓括號強行指定運算次序。需牢記:乘除高於加減,賦值優先級非常低。此外,屬性存取與呼叫運算式的優先級比所有運算子都高。

v. 運算子的結合性

結合性決定了多個同優先級運算子的運算順序。減法由左到右結合:

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))

vi. 運算順序

運算子的優先級與結合性規定了運算順序,但並未規定子運算式的計算順序。JavaScript 總是嚴格從左至右計算運算式。

八、算術運算式

基本算術運算子是 *、/、%、+、-。除了加法外,其餘運算子只是在必要時將操作數轉為數字,再求積、商、餘與差;無法轉為數字者會轉為 NaN。JavaScript 所有數字皆為浮點數,故 5/2 結果為 2.5 而非 2;除數為 0 時結果為正或負無窮大,0/0 則為 NaN,且不會報錯。% 運算子計算餘數,結果符號與被除數一致,例如 5%2 為 1、-5%2 為 -1。

i.「+」運算子

二元加法運算子「+」可做數字加法,也可做字串連接:

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"

ii. 一元運算子

一元運算子作用於單一操作數並產生新值,優先級很高且為右結合。

一元加法 +:把操作數轉為數字(或 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。

iii. 位運算子

位運算子對數字的二進位表示進行按位運算,因為作用於數值並回傳數字,這裡歸類為算術運算子。它們在 JavaScript 中不常見。

九、關聯運算式

關聯運算子用於測試兩個值之間的關係(相等、小於、「是…的屬性」),依關係是否存在而回傳 true 或 false。關聯運算式總是回傳布林值,常用於 if、while、for 等語句以控制流程。

i. 相等與不等運算子

「===」是嚴格相等運算子(恆等運算子),比較時不做任何型別轉換;「==」是相等運算子,比較時允許型別轉換。「!=」與「!==」則分別是它們的求反。

嚴格相等「===」的規則:型別不同則不相等;兩者皆為 null 或 undefined 則相等;皆為相同布林值則相等;任一為 NaN 則不相等(NaN 與任何值都不等,含自身);數字相等(0 與 -0 相等)則相等;字串需對應位 16 位值完全相同才相等;兩個參照指向同一物件才相等。

相等運算子「==」在型別不同時會嘗試轉換:null 與 undefined 相等;數字與字串先將字串轉數字;true 轉 1、false 轉 0;物件與數字或字串時先將物件轉原始值再比較;其他不同型別的比較皆不相等。

ii. 比較運算子

比較運算子(<、<=、>、>=)只有數字與字串能真正執行比較,其他型別會先轉為原始值。若兩者皆為字串,則依 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。

iii. in 運算子

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 的元素

iv. instanceof 運算子

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。

十、邏輯運算式

邏輯運算子「&&」、「||」、「!」對操作數進行布林運算,常與關聯運算子搭配,將多個關聯運算式組合成更複雜的運算式。

i. 邏輯與(&&)

「&&」可從三個層次理解:最簡單的一層是當操作數皆為布林值時執行布林與運算,只有兩者皆為 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

因此當右側運算式具有副作用(賦值、遞增、函式呼叫)時要格外小心,因為它是否執行取決於左操作數的結果。

ii. 邏輯或(||)

「||」對兩個操作數做布林或運算。與「&&」類似,它也具備短路行為:先計算左操作數,若為真值則回傳,否則再計算右操作數。最常見的用法是從一組備選運算式中選取第一個真值,常用於提供參數預設值:

var max = max_width || preferences.max_width || 500;

function copy(o, p) {
  p = p || {}; // 若未傳入 p,則使用新建立的物件
}

iii. 邏輯非(!)

「!」是一元運算子,先將操作數轉為布林值再求反,因此總是回傳 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 含有副作用運算式(如函式呼叫與賦值)時,兩者並不等價。

十二、運算式計算(eval)

和許多解譯語言一樣,JavaScript 能透過全域函式 eval() 解譯執行由原始碼組成的字串並產生一個值:

eval("3+2"); // => 5

eval() 只有一個參數:若非字串則直接回傳該參數;若是字串則編譯執行,回傳最後一個運算式或語句的值(無值則回傳 undefined),編譯失敗則拋出語法錯誤。

關於 eval() 最重要的是,它使用呼叫它的變數作用域環境,因此能讀寫、定義局部變數與函式。

ii. 全域 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

十三、其他運算子

i. 條件運算子(?:)

條件運算子是 JavaScript 中唯一的三元運算子,有三個操作數。若第一個操作數(作為布林值)為真值,則計算並回傳第二個;否則計算並回傳第三個。第二與第三個操作數必會計算其一:

x > 0 ? x : -x; // 求 x 的絕對值
grett = "hello" + (username ? username : "guest");

ii. typeof 運算子

typeof 是一元運算子,回傳表示操作數類型的一個字串:

undefined        => "undefined"
null             => "object"
true 或 false     => "boolean"
任意數字或 NaN     => "number"
任意字串          => "string"
任意函式          => "function"
任意物件(非函式) => "object"

它常寫在運算式中,也可加上圓括號讓它看起來像函式:

(typeof value == "string") ? "" + value + "" : value;
typeof(i)

iii. delete 運算子

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

iv. void 運算子

void 是一元運算子,操作數會照常計算,但忽略結果並回傳 undefined。因此當操作數具有副作用時使用 void 才有意義,最常用於帶客戶端的 URL,讓瀏覽器不顯示運算結果:

<a href="javascript:void window.open();">new</a>

v. 逗號運算子(,)

逗號運算子是二元運算子,先計算左操作數再計算右操作數,並回傳右操作數的值。左側運算式的計算結果會被忽略,因此只有當左側具有副作用時才有意義。它最常用於 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 運算式與運算子的完整梳理,掌握這些規則,就能讀懂並寫出語意清晰的程式碼。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved