本文整理自 JavaScript 核心讀書筆記,系統性地梳理了型別、值與變數這三大基礎概念,適合想打好底子的開發者參考。
電腦程式的運行需要對各種「值」(value)進行操作,例如數字 3.14 或文字 "hello world"。在程式語言中,能表示並操作這些值的型別叫做資料型別(type),而支援多種資料型別正是程式語言最基本的特性之一。當程式需要把值保留起來以備日後使用時,便將其賦值給一個變數(variable)——變數是值的符號名稱,可透過名稱取得對值的參照。
JavaScript 的資料分為兩大類:原始型別(primitive type)與物件型別(object type)。
原始型別包括數字、字串與布林值。此外還有兩個特殊的原始值:null(空)與 undefined(未定義),它們分別是各自型別的唯一成員,不屬於數字、字串或布林值。
除了上述原始值之外,其餘都是物件。物件是屬性(property)的集合,每個屬性由「名/值對」構成,值可以是原始值,也可以是物件。JavaScript 中的全域物件(global object)是一個比較特殊的物件。
普通物件是「命名值」的無序集合。JavaScript 同時定義了幾種特殊物件:
若以 new 運算子初始化一個新物件,我們稱之為構造函式(constructor)。每個構造函式定義了一類(class)物件。除了陣列類與函式類之外,JavaScript 還定義了日期(Date)、正則(RegExp)與錯誤(Error)三種常用類別,我們也能定義自己的構造函式來建立所需的類。
JavaScript 解譯器具備自動垃圾回收(garbage collection)機制,程式可依需建立物件,不必擔心銷毀與記憶體回收——當不再有任何參照指向某物件時,解譯器便會自動回收它佔用的記憶體。
JavaScript 是一種物件導向語言。嚴格來說,這意味著資料型別本身可以定義方法(method)來操作值。例如要對陣列 a 排序,不必把 a 傳入 sort() 函式,而是直接呼叫 a 的方法:
a.sort(); // sort(a) 的物件導向版本
技術上只有物件才能擁有方法,但數字、字串與布林值也擁有自己的方法。在 JavaScript 中,只有 null 與 undefined 無法擁有方法。
JavaScript 的型別也可分為可變(mutable)與不可變(immutable)兩類。物件與陣列屬於可變型別,程式可改變物件屬性值與陣列元素值;而數字、布林值、null 與 undefined 屬於不可變型別。字串雖可視為字元組成的陣列,但在 JavaScript 中它是不可變的——你可以存取字串中任意位置的文字,卻無法修改既有字串的內容。
JavaScript 能自由進行型別轉換。例如在期望字串的地方使用數字,它會自動將數字轉為字串;在期望布林值的地方使用非布林值,它也會相應轉換。這些靈活的轉換規則也影響了「判斷相等」的行為。
JavaScript 的變數是無型別的(untyped),可被賦予任何型別的值,並以 var 關鍵字宣告。JavaScript 採用語法作用域,不在任何函式內宣告的變數稱為全域變數(global variable),它在整個程式中都看得見。
與其他語言不同,JavaScript 不區分整數與浮點數,所有數值皆以浮點數表示。當數字直接出現在程式中,我們稱之為數字直接量(numeric literal)。
十進制整數以數字序列表示。除了十進制,JavaScript 也識別以 0x 或 0X 為前綴的十六進制值,其後緊跟由 0-9 與 a(A)-f(F) 組成的數串(a-f 代表 10-15):
0xff // 15*16+15 = 255 0xCAFE911
雖然 ECMAScript 不支援八進制直接量,但某些實作允許以數字 0 開頭表示八進制:
0377 // 3*64 + 7*8 + 7 = 255(十進制)
由於各實作對八進制的支援不一,加上 ECMAScript 6 嚴格模式明令禁止使用八進制直接量,因此不建議使用以 0 為前綴的整數直接量。
浮點型直接量可含小數點,採用傳統實數寫法;也可使用指數計數法,即在實數後接字母 e 或 E,再跟正負號與整數指數,代表實數乘以 10 的指數冪。其語法可概括為:
[digits][.digits][(E|e)[(+|-)]digits]
3.14
2345.455
.33333333333333333
6.02e23 // 6.02*10 的 23 次方
1.255454E-23 // 1.255454*10 的負 23 次方
除了基本的 +、-、*、/ 與求餘(%)運算子外,JavaScript 還透過 Math 物件的屬性與函式提供更複雜的運算:
Math.pow(2, 53) // => 9007199254740992 Math.round(.6) // => 1.0 四捨五入 Math.ceil(.6) // => 1.0 向上求整 Math.floor(.6) // => 0.0 向下求整 Math.abs(-5) // => 5 求絕對值 Math.max(x, y, z) // 回傳最大值 Math.min(x, y, z) // 回傳最小值 Math.random() // 產生 0 到 1 之間的偽隨機數 Math.PI // 圓周率 π Math.E // 自然對數的底數 e Math.sqrt(3) // 3 的平方根 Math.pow(3, 1/3)// 3 的立方根 Math.sin(0) // 三角函式,另有 Math.cos、Math.atan 等 Math.log(10) // => 2.302585092994046 自然對數 Math.log(512) / Math.LN2 // 以 2 為底的 512 的對數 Math.log(100) / Math.LN10 // 以 10 為底的 100 的對數 Math.exp(3) // e 的三次冪
當運算結果超過可表示的數值上限(溢出 overflow)時,結果為特殊的無窮大值 Infinity;負數超過範圍則為 -Infinity。下溢(underflow)發生在運算結果無限接近零、比可表示的最小值還小時,此時會回傳特殊的「負零」。
JavaScript 預定義了全域變數 Infinity 與 NaN。ECMAScript 3 中這兩個值可讀寫,ECMAScript 5 則將其定義為唯讀:
Infinity // 正無窮大 Number.POSITIVE_INFINITY // 同值,唯讀 1 / 0 // 同值 Number.MAX_VALUE + 1 // 結果仍是 Infinity Number.NEGATIVE_INFINITY // 負無窮大 NaN // 非數字值 Number.NaN // 同值,唯讀 0/0 // 結果仍是 NaN Number.MIN_VALUE/2 // 發生下溢,結果為 0 -Number.MIN_VALUE/2 // 負零 -1/Infinity // 負零 -0 // 負零
NaN 有個特殊之處:它與任何值都不相等,包括自身,因此不能用 x == NaN 來判斷,而應使用 x != x(僅當 x 為 NaN 時結果為 true)。函式 isNaN() 若參數為 NaN 或非數字值則回傳 true;isFinite() 則在參數不是 NaN、Infinity 或 -Infinity 時回傳 true。
實數有無限多個,但 JavaScript 以浮點數只能表示有限個,因此使用實數時往往只是真實值的近似。JavaScript 採用 IEEE-754 浮點數表示法,這是二進位表示法,能精確表示 1/2、1/8、1/1024 等分數,卻無法精準表示 0.1 這類十進位小數:
var x = .3 - .2; var y = .2 - .1; alert(x == y) // => false 兩值不相等 x == .1 // => false 0.3-0.2 不等於 0.1 y == .1 // => true 0.2-0.1 等於 0.1
由於捨入誤差,0.3 與 0.2 的近似差實際上不等於 0.2 與 0.1 的近似差(真實模擬環境中 0.3-0.2 = 0.09999999999999998)。這問題存在於所有採用二進位浮點數的語言中。若要做重要的金融計算,可考慮以大整數(例如以「分」而非「元」為單位)運算來避開誤差。
JavaScript 核心包含 Date() 構造函式,用來建立日期與時間物件,並提供簡單的 API 供日期計算:
var zhen = new Date(2011, 0, 1); // 2011 年 1 月 1 日 var later = new Date(2011, 0, 1, 17, 10, 30); // 同一天的具體時刻 var now = new Date(); // 當前日期與時間 var elapsed = now - zhen; // 日期相減,計算間隔毫秒數 later.getFullYear(); // => 2011 later.getMonth(); // => 0(從 0 開始計數的月份) later.getDate(); // => 1(從 1 開始計數的天數) later.getDay(); // => 5(星期幾,0 代表週日) later.getHours(); // => 當地時間小時 later.getUTCHours(); // => 以 UTC 表示的小時
字串(string)是一組 16 位值組成的不可變有序序列,每個字元通常來自 Unicode 字元集。字串長度(length)即所含 16 位值的個數,索引從 0 開始。空字串長度為 0,JavaScript 並沒有「字元型」。
JavaScript 採用 UTF-16 編碼的 Unicode 字元集。最常用的字元以 16 位內碼表示,無法用 16 位表示者則依 UTF-16 規則以兩個 16 位值組成的「代理項對」表示,因此一個長度為 2 的字串可能只代表一個 Unicode 字元:
var p = "π"; // π 由 16 位內碼表示 0x03c0 var e = "e"; // e 由 17 位內碼表示 0x1d452 p.length // => 1,p 包含一個 16 位值 e.length // => 2,e 經 UTF-16 編碼後包含兩個值
JavaScript 的字串操作方法皆作用於 16 位值而非字元,且不會對代理項對做單獨處理。
字串直接量由單引號或雙引號括起的字元序列構成。單引號定界的字串中可含雙引號,反之亦然:
"" // 空字串 'testing' "3.14" 'name="myform"' "wouldn't you prefer O'Reilly's book?"
ECMAScript 3 要求字串直接量寫在一行,ECMAScript 5 則允許拆分為多行,每行以反斜線(\)結尾;若希望換行則使用 \n。
在字串中,反斜線(\)後接一個字元即構成轉義字元:
\o // NUL 字元 \b // 退格符 \t // 水平定位字元 \n // 換行符 \v // 垂直定位字元 \f // 換頁符 \r // 回車符 \" // 雙引號 \\ // 反斜線 \xXX // 由兩位十六進位指定的 Latin-1 字元 \xXXXX // 由四位十六進位指定的 Unicode 字元
將 + 運算子用於字串代表字串連接:
var msg = "hello" + "world"; // 產生 "helloworld"
字串長度可用 length 屬性取得(s.length)。此外字串還提供許多方法:
var s = "hello,world";
s.charAt(0); // "h" 第一個字元
s.charAt(s.length - 1); // "d" 最後一個字元
s.substring(1, 4); // "ell"
s.slice(1, 4); // "ell" 同上
s.slice(-3); // 最後出現的 3 個字元
s.indexOf("l"); // 2,字元 l 首次出現的位置
s.lastIndexOf("l"); // 10,字元 l 最後一次出現的位置
s.indexOf("l", 3); // 位置 3 之後 l 首次出現的位置
s.split(","); // => ["hello","world"]
s.replace("h", "H"); // => "Hello,world"
s.toUpperCase(); // => "HELLO,WORLD"
在 JavaScript 中字串固定不變,replace()、toUpperCase() 等方法都會回傳新字串,原字串本身並未改變。字串也可當作唯讀陣列,用方括號存取單一字元:s[0] => "h"。
JavaScript 定義了 RegExp() 構造函式來建立表示文字模式匹配的物件,這些模式稱為「正則表達式」。正則表達式雖非基本資料型別,卻有直接量寫法,兩條斜線之間的文本即構成一個正則表達式:
/^HTML/ // 匹配以 HTML 開始的字串 /[1-9][0-9]*/ // 匹配一個非零數字,後接任意個數字 /\bjavascript\b/i // 匹配單字 javascript,忽略大小寫
RegExp 物件與字串都定義了可利用正則表達式進行匹配的方法:
var text = "testing:1,2,3"; var pattern = /\d+/g; // 匹配所有含一個或多個數字的實例 pattern.test(text); // => true,匹配成功 text.search(pattern); // => 9,首次匹配成功的位置 text.match(pattern); // => ["1","2","3"] 所有匹配組成的陣列 text.replace(pattern, "#"); // => "testing:#,#,#" text.split(/\D+/); // => ["","1","2","3"],以非數字字元截取
布林值代表真或假,只有 true 與 false 兩個值。JavaScript 中比較運算的結果通常就是布林值:
a == 4
布林值常用於控制語句,例如 if/else:
if (a == 4) b = b + 1; else a = a + 1;
任意值都能轉為布林值,以下六個值會被轉為 false:
undefined null 0 -0 NaN "" // 空字串
其他所有值(包括所有物件)都會轉為 true。這六個被轉為 false 的值有時稱為「假值」。布林值包含 toString() 方法,此外還有 &&、|| 與一元 ! 三個重要的布林運算子:
if ((x == 0 && y == 0) || !(z == 0)) {
// x 與 y 都是零,或 z 是非零
}
null 是 JavaScript 的關鍵字,表示特殊的「空值」。對 null 執行 typeof 會回傳 object,因此可將 null 視為一個特殊的物件值,代表「非物件」。null 通常被視為其自身型別的唯一成員,用來表示數字、字串或物件是「無值」的。
undefined 則是第二個表示「值空缺」的值,代表變數尚未初始化,或物件屬性/陣列元素不存在。它是預定義的全域變數(並非關鍵字),以 typeof 測試會回傳 "undefined"。
null 與 undefined 雖不同,但都表示「值的空缺」,且以 == 判斷時被視為相等(需用 === 才能區分)。在期望布林值的地方兩者皆為假值,且都不含任何屬性與方法,對它們取值會產生型別錯誤。
全域物件(global object)在 JavaScript 中有著重要用途,其屬性即全域定義的符號。解譯器啟動時會建立一個全域物件並賦予初始屬性,包括:
在客戶端 JavaScript 中,window 物件充當全域物件。若程式宣告了一個全域變數,它就是全域物件的一個屬性。
字串並非物件,卻擁有屬性與方法,這是因為當參照字串屬性時,JavaScript 會以 new String(s) 的方式暫時將它轉為物件來處理屬性參照,處理完畢後這個臨時物件便被銷毀:
var s = "hello world";
var word = s.substring(s.indexOf(" ") + 1, s.length); // 使用字串屬性
document.write(word);
數字與布林值同樣具備各自的方法,透過 Number() 與 Boolean() 建立臨時物件來呼叫(null 與 undefined 沒有包裝物件,存取其屬性會發生型別錯誤)。以下程式說明了臨時物件的特性:
var s = "test"; s.len = 4; // 試圖設定屬性,但作用於臨時物件,隨即被銷毀 var t = s.len; // => undefined
也可顯式建立包裝物件:
var s = "test", n = 1, b = true; var S = new String(s); var N = new Number(n); var B = new Boolean(b);
== 運算子會將原始值與其包裝物件視為相等,但 === 則視為不等,typeof 也能看出兩者的差異。
原始值(undefined、null、布林值、數字、字串)與物件(含陣列與函式)有著根本差異:原始值不可變更,任何方法都無法改變它。
var s = "hello world"; s.toUpperCase(); // 回傳 "HELLO WORLD",並未改變 s s // => "hello world"
原始值的比較是「值的比較」,只有值相等時才相等。而物件是「參照型別(reference type)」,其比較是參照的比較——即使兩個物件擁有完全相同的屬性與值,只要不是同一個物件就不相等:
var o = {x: 1}, p = {x: 1};
o === p; // => false,兩個獨立物件永不相等
var a = [], b = [];
a === b; // => false,兩個獨立陣列永不相等
將物件賦值給變數,只是複製了參照,物件本身並未被複製:
var a = []; var b = a; // b 參照同一個陣列 b[0] = 1; a[0] // => 1,a 也會被修改 a === b // => true,a 與 b 參照同一個陣列
若要得到物件或陣列的複本,必須顯式複製每個屬性或元素:
var a = ['a', 'b', 'c']; // 待複製的陣列
var b = []; // 複製到的目標空陣列
for (var i = 0; i < a.length; i++) {
b[i] = a[i];
}
同理,要比較兩個獨立陣列,必須逐一比較元素:
function equalArrays(a, b) {
if (a.length != b.length) return false; // 長度不同則不相等
for (var i = 0; i < a.length; i++) // 遍歷所有元素
if (a[i] !== b[i]) return false; // 任一元素不等則不相等
return true; // 否則相等
}
JavaScript 的型別轉換非常靈活:
10 + "object" // => "10object" "7" * "4" // => 28,兩個字串均轉為數字 var n = 1 - "x" // => NaN,字串 x 無法轉為數字 n + " objects" // => "NaN objects"
原始值轉字串的情形已明確定義;轉數字則較微妙——以數字表示的字串可直接轉為數字(前後允許空格),但含非數字字元則結果為 NaN。有些轉換看來奇怪:true 轉為 1,false 與空字串 "" 轉為 0。原始值轉物件則透過 String()、Number() 或 Boolean() 建立各自的包裝物件,而 null 與 undefined 用在期望物件的地方會造成型別錯誤。
由於 JavaScript 能靈活轉換型別,== 相等運算子的含義也隨之變得多樣。以下比較結果皆為 true:
null == undefined // 這兩值被認為相等 "0" == 0 // 比較前字串轉為數字 0 == false // 布林值轉為數字 "0" == false // 字串與布林值都轉為數字
需特別注意:一個值轉換為另一個值,並不意味著兩者相等。if 語句會把 undefined 轉為 false,但這不表示 undefined == false。
最簡單的顯式轉換方式是使用 Boolean()、Number()、String() 或 Object()(不加 new 時作為轉換函式):
Number("3") // => 3
String(false) // => "false"
Boolean([]) // => true
Object(3) // => new Number(3)
某些運算子也會做隱式轉換:
x + "" // 等同 String(x) +x // 等同 Number(x),也可寫成 x - 0 !!x // 等同 Boolean(x)
Number 類別的 toString() 可接受表示基數的參數(範圍 2-36):
var n = 17; b_string = n.toString(2); // 轉為 10001 o_string = "0" + n.toString(8); // 轉為八進位 021 hex_string = "0x" + n.toString(16); // 轉為十六進位 0x11
另有三個方法控制數字到字串的輸出格式:
var n = 123456.789; n.toFixed(0); // "123457" n.toFixed(2); // "123456.79" n.toFixed(5); // "123456.78900" n.toExponential(1); // "1.2e+5" n.toExponential(3); // "1.235e+5" n.toPrecision(4); // "1.235e+5" n.toPrecision(7); // "123456.8" n.toPrecision(10); // "123456.7890"
字串轉數字方面,parseInt() 只解析整數,parseFloat() 可解析整數與浮點數:
parseInt("3many nice") // => 3
parseFloat("3.14meters") // => 3.14
parseInt("-12.34") // => -12
parseInt("0xff") // => 255
parseFloat(".1") // => 0.1
parseInt("0.1") // => 0
parseInt(".1") // => NaN,不能以 . 開始
parseInt() 還可接受第二個參數指定基數(2-36):
parseInt("11", 2) // => 3(1*2+1)
parseInt("ff", 16) // => 255
parseInt("zz", 36) // => 1295
parseInt("077", 8) // => 63
parseInt("077", 10) // => 77
所有物件都轉為 true。物件到字串與物件到數字的轉換透過 toString() 與 valueOf() 兩個方法完成。預設的 toString() 不會回傳有趣的值:
({x:1, y:2}).toString(); // => "[object object]"
許多類別定義了更具體的 toString():
[1, 2, 3].toString(); // => "1,2,3"
(function(x){f(x);}).toString(); // => 函式的原始碼字串
/\d+/g.toString(); // => /\d+/g
new Date(2015, 0, 1).toString(); // => 可讀的日期字串
valueOf() 則傾向於將物件轉為原始值。陣列、函式與正則表達式繼承預設方法,回傳物件本身;日期類別的 valueOf() 回傳自 1970 年 1 月 1 日以來的毫秒數:
var d = new Date(2015, 0, 1); d.valueOf(); // => 1420041600000
使用變數前應先以 var 宣告,也可一次宣告多個並同時指定初始值:
var i; var sum; var i, sun; var message = "hello"; var i = 0, j = 0, k = 0;
在 for 與 for/in 迴圈中也可使用 var 宣告迴圈變數:
for (var i = 0; i < 10; i++) log(i); for (var i = 0, j = 10; i < 10, j = 100; i++, j--) console.log(i * j) for (var p in o) console.log(p);
JavaScript 的變數是無型別的,同一變數可被賦予不同型別的值:
var i = 10; i = "ten";
變數的作用域(scope)是原始碼中定義該變數的區域。全域變數擁有全域作用域,在程式任何地方都看得見;在函式內部宣告的變數則是局部變數,只在函式體內有效。函式參數也是局部變數。函式內局部變數的優先級高於同名全域變數:
var scope = "global"; // 全域變數
function checkscope() {
var scope = "local"; // 同名的局部變數
return scope;
}
checkscope(); // => "local"
雖然全域作用域下可省略 var,但宣告局部變數時則必須使用 var,否則會不小心改動全域變數或污染全域命名空間:
scope = "global"; // 甚至不用 var 宣告全域變數
function checkscope2() {
scope = "local"; // 修改了全域變數
myscope = "local"; // 隱式宣告了一個新的全域變數
return [scope, myscope];
}
checkscope2(); // => ["local","local"],產生了副作用
scope // => "local",全域變數被修改
myscope // => "local",全域命名空間被搞亂
函式定義可以嵌套,因而形成多層局部作用域:
var scope = "global scope"; // 全域變數
function checkscope() {
var scope = "local scope"; // 局部變數
function nested() {
var scope = "nested scope"; // 嵌套作用域內的局部變數
return scope;
}
return nested();
}
checkscope(); // => "nested scope"
類似 C 語言的語言具有「塊級作用域(block scope)」,變數在宣告它們的區塊外不可見;而 JavaScript 沒有塊級作用域,取而代之的是「函式作用域(function scope)」——變數在宣告它們的函式體及所有嵌套函式體內都有意義。
function test(o) {
var i = 0; // i 在整個函式體內皆有定義
if (typeof o == "object") {
var j = 0; // j 在函式體內有定義,不僅在這個區塊內
for (var k = 0; k < 10; k++) { // k 在函式體內有定義,不僅在迴圈內
console.log(k); // 輸出 0-9
}
console.log(k); // k 已定義,輸出 10
}
console.log(j); // j 已定義,但可能未初始化
}
由於函式作用域的特性,變數在宣告之前甚至就「可用」,這被非正式地稱為宣告提前(hoisting):函式裡宣告的所有變數(但不含賦值)都會被提前到函式頂部:
var scope = "global";
function f() {
console.log(scope); // 輸出 "undefined",而非 "global"
var scope = "local"; // 變數在這裡賦初值,但本身在函式內任何地方皆有定義
console.log(scope); // 輸出 "local"
}
上述過程等價於將變數宣告「提前」至函式頂部,同時把初始化留在原處:
function f() {
var scope; // 在函式頂部宣告局部變數
console.log(scope); // 變數存在,但值為 "undefined"
scope = "local"; // 在此初始化並賦值
console.log(scope); // 這裡它具有我們期望的值
}
宣告 JavaScript 全域變數時,其實就是定義了全域物件的一個屬性。以 var 宣告的屬性不可配置,無法用 delete 刪除;而未經宣告就賦值的變數則是全域物件正常且可刪除的屬性:
var truevar = 1; // 宣告一個不可刪除的全域變數 fakevar = 2; // 建立全域物件一個可刪除的屬性 this.fakevar2 = 3; // 同上 delete truevar // => false,變數並未被刪除 delete fakevar // => true,變數被刪除 delete this.fakevar2 // => true,變數被刪除
JavaScript 是基於詞法作用域的語言:透過閱讀包含變數定義的原始碼,就能知道變數的作用域。全域變數在程式中始終有定義;局部變數則在宣告它的函式體內及其嵌套的函式內始終有定義。