本文把 JavaScript 最常被翻查的核心概念整理成一份完整筆記,涵蓋資料型別、變數作用域、嚴格模式、物件與資料結構、函式,以及兩種定義類別的方式。
JavaScript 提供三種元資料型別:string、number、boolean,可用 typeof(v) 測試。另有五種基本引用類型:Object、Array、Function、Date、RegExp。其中 Array、Function、Date、RegExp 屬於特殊類型,嚴格說 Date 與 RegExp 也可視為可封裝的元資料型別。
變數、陣列元素、函式參數與回傳值都不需要宣告型別,型別轉換會自動進行。變數的值可以是:數值(字串、數字或布林)、物件引用(可指向資料、函式、日期或正則)、特殊的 null(通常用於初始化物件),以及 undefined(已宣告但未賦值)。
if (firstName + lastName === "James Bond") ...
numeric 表示 64 位元浮點數,JavaScript 不明顯區分整數與浮點數。若某個運算式的值不等於任何數字,其值會是 NaN,可搭配 isNaN() 使用。

ES5 只有兩種作用域:全域與函式作用域,並沒有區塊作用域。因此下面這種常見寫法其實是個陷阱——i 在函式結束後仍然存在。
function foo() {
for (var i = 0; i < 10; i++) {
... // 對 i 做一些事
}
}
建議把所有變數宣告集中在函式開頭。ES6 之後支援區塊作用域,用 let 宣告即可。
從 ES5 開始,嚴格模式用於在執行期抓出更多錯誤:所有變數都必須先宣告,對未宣告的變數賦值會丟出例外。在檔案或 script 元素最前面寫入:
use strict;
除非專案依賴的函式庫不相容,否則建議一律開啟。
JavaScript 的物件概念與 OO 語言中的物件不同:物件不需要先具現化類別,也能有自己的方法,除了屬性槽之外還包含方法槽與鍵值槽,共三種 slots。
var person1 = { lastName: "Smith", firstName: "Tom" };
var o1 = Object.create(null); // 沒有任何槽的空物件
屬性可用兩種方式存取:
person1.lastName = "Smith"; person1["lastName"] = "Smith";
JavaScript 物件常見的五種用途:
1. Record(紀錄)——純屬性集合:
var myRecord = {firstName: "Tom", lastName: "Smith", age: 26};
2. Map(映射)——鍵值對集合:
var numeral2number = {"one": "1", "two": "2", "three": "3"};
3. 無型別物件——同時含屬性與方法,不需具現化類別:
var person1 = {
lastName: "Smith",
firstName: "Tom",
getFullName: function () {
return this.firstName + " " + this.lastName;
}
};
4. Array List——以索引存取的邏輯資料結構:
var a = [1,2,3];
a[4] = 7; // 陣列可動態增長
a.push(newElement); // 新增
a.splice(i, 1); // 刪除
if (a.indexOf(v) > -1) ... // 查找
Array.isArray(a); // 判定是否為陣列
var i = 0;
for (i = 0; i < a.length; i++) { console.log(a[i]); }
a.forEach(function (elem) { console.log(elem); });
var clone = a.slice(0); // 複製
var myTranslation = {
"my house": "mein Haus",
"my boat": "mein Boot",
"my horse": "mein Pferd"
};
myTranslation["my car"] = "mein Auto"; // 新增
delete myTranslation["my car"]; // 刪除
if ("my bike" in myTranslation) ... // 查找
var i = 0, key = "", keys = [];
keys = Object.keys(myTranslation);
for (i = 0; i < keys.length; i++) {
key = keys[i];
console.log(myTranslation[key]);
}
Object.keys(myTranslation).forEach(function (key) {
console.log(myTranslation[key]);
});
var clone = JSON.parse(JSON.stringify(myTranslation)); // 複製
array lists(如 ["one","two","three"])、records(如 {firstName:"Tom", lastName:"Smith"})、maps(如 {"one":1,"two":2}),以及 entity table——一種值為固定 ID 紀錄的特殊 map。

record、map、entity 在概念上有區分,但對 JavaScript 引擎而言都是物件。
函式是特殊的 JavaScript 物件,具 name 與 length(參數個數)屬性。判定方式:
if (typeof(v) === "function") {...}
函式表達式與函式宣告:
var myFunction = function theNameOfMyFunction () {...}
function theNameOfMyFunction () {...}
// 等價於
var theNameOfMyFunction = function theNameOfMyFunction () {...}
省略名稱就是匿名函式,在其他語言中稱為 lambda 表達式,常用來當作排序等 API 的比較器:
var list = [[1,2],[1,3],[1,1],[2,1]];
list.sort(function (x, y) {
return ((x[0] === y[0]) ? x[1] - y[1] : x[0] - y[0]);
});
閉包:函式可以存取定義位置之外的變數,因此不必把外部結果透過參數傳進來。
var sum = function (numbers) {
var result = 0;
numbers.forEach(function (n) { result += n; });
return result;
};
console.log(sum([1,2,3,4]));
arguments 物件:可用來存取函式內的所有參數,有 length 與索引,但它不是 Array 的實例,所以不能用 forEach 等方法。因此也可以定義不帶參數的函式:
var sum = function () {
var result = 0, i = 0;
for (i = 0; i < arguments.length; i++) {
result = result + arguments[i];
}
return result;
};
console.log(sum(0,1,1,2,3,5,8)); // 20
若想在 arguments 上使用陣列方法,可以借 call 借用:
var sum = function () {
var result = 0;
Array.prototype.forEach.call(arguments, function (n) {
result = result + n;
});
return result;
};
Function.prototype.call 與 apply 的存在,就是為了改變函式運行時的 context。
類別在 JavaScript 中需要滿足:能指定名稱與各層級的屬性和方法、能檢驗實例歸屬、能支援屬性與方法繼承。ES6 之前沒有統一規範,常見做法有兩種:以建構函式搭配原型鏈,或是以 Object.create 為核心的 factory 物件。
class Person {
constructor(first, last) {
this.firstName = first;
this.lastName = last;
}
toString() {
return this.firstName + " " + this.lastName;
}
static checkLastName(ln) {
if (typeof(ln) !== "string" || ln.trim() === "") {
console.log("Error: invalid last name!");
}
}
}
Person.instances = {}; // 類層級的靜態屬性
class Student extends Person {
constructor(first, last, studNo) {
super(first, last);
this.studNo = studNo;
}
// 覆寫父類方法
toString() {
return super.toString() + "(" + this.studNo + ")";
}
}
// 1. 建構函式,this 指向新建立的物件
function Person(first, last) {
this.firstName = first;
this.lastName = last;
}
// 2. 實例層方法
Person.prototype.toString = function () {
return this.firstName + " " + this.lastName;
};
// 3. 靜態方法
Person.checkLastName = function (ln) {
if (typeof(ln) !== "string" || ln.trim() === "") {
console.log("Error: invalid last name!");
}
};
// 4. 靜態屬性
Person.instances = {};
// 5. 定義子類,並呼叫父類建構函式完成屬性繼承
function Student(first, last, studNo) {
Person.call(this, first, last);
this.studNo = studNo;
}
// 6. 透過 prototype 安裝方法繼承
Student.prototype = Object.create(Person.prototype);
Student.prototype.constructor = Student;
// 7. 覆寫父類方法
Student.prototype.toString = function () {
return Person.prototype.toString.call(this) + "(" + this.studNo + ")";
};
// 8. 具現化
var pers1 = new Person("Tom", "Smith");
alert("The full name of the person are: " + pers1.toString());
定義一個帶有 create 方法的物件,內部呼叫預先定義好的 Object.create 來產生實例。
var Person = {
name: "Person",
properties: {
firstName: {range: "NonEmptyString", label: "First name", writable: true, enumerable: true},
lastName: {range: "NonEmptyString", label: "Last name", writable: true, enumerable: true}
},
methods: {
getFullName: function () {
return this.firstName + " " + this.lastName;
}
},
create: function (slots) {
var obj = Object.create(this.methods, this.properties);
// 加上 direct type 屬性
Object.defineProperty(obj, "type", {
value: this, writable: false, enumerable: true
});
// 初始化
Object.keys(slots).forEach(function (prop) {
if (prop in this.properties) obj[prop] = slots[prop];
});
return obj;
}
};
var pers1 = Person.create({firstName: "Tom", lastName: "Smith"});
alert("The full name of the person are: " + pers1.getFullName());
這裡的 Person 物件實際上代表一個 factory-based 類別,每個屬性宣告都透過 Object.create 的第二個參數描述其 writable 與 enumerable 特性。兩種寫法沒有絕對優劣:class 語法語意清楚、工具支援好;factory 寫法則在需要嚴格控制屬性描述與避免 new 時更靈活。