這份筆記把 JavaScript 最常被考、也最容易混淆的基礎觀念整理成一份清單,從變數作用域一路談到物件建立與繼承的實作方式。
定義在函式外的變數一定是全域變數。定義在函式內的變數,若宣告了 var 則是區域變數;若沒有宣告 var,則會變成全域變數。
var global = "Global";
test();
function test() {
var local = "Local";
document.writeln(global);
document.writeln(local);
}
document.writeln(global);
document.writeln(local); // ReferenceError: local is not defined
在 JavaScript 中,函式(function)本身就是物件,可以賦值、傳參、掛屬性。
JavaScript 不支援函式重載。宣告兩個同名的函式,後者會直接覆蓋前者。
JavaScript 有一個 Function 物件,所有自訂函式都是 Function 型別。Function 建構式接受的所有參數都是字串,其中最後一個參數是函式主體,前面的參數則是函式真正的形參。
var add = new Function('a', 'b', 'return a + b;');
console.log(add(1, 2)); // 3
每個函式都有一個隱含的 arguments 物件,代表實際傳入的參數集合,arguments.length 即實際傳入的參數個數。
每個函式物件都有一個 length 屬性,表示該函式期望接受的參數個數;而 arguments.length 表示實際傳入的參數個數。兩者不可混為一談。
Undefined、Null、Boolean、Number、String。(注意:JavaScript 沒有 char 型別。)
undefined。null。true 與 false。typeof 是一元運算子,後接變數名稱,用來取得型別,可能回傳五個值:undefined、boolean、number、string、object(以及 function)。
若函式沒有宣告回傳值,執行結果是 undefined。
可以說 undefined 是從 null 派生出來的,因此相等運算子認為兩者相等:
alert(undefined == null); // true
有三種:Boolean(value)、Number(value)、String(value)。
所有物件都繼承自 Object。用 for...in 走訪一個剛建立的 Object,不會印出任何東西,但這不代表它沒有屬性:
var object = new Object();
for (var v in object) {
alert(v);
}
可以用 propertyIsEnumerable 測試屬性是否可列舉:
alert(object.propertyIsEnumerable("prototype")); // false
回傳 false 說明 Object 的屬性無法列舉。相較之下,window 物件的屬性是可以列舉的:
for (var v in window) {
console.log(v);
}
在 Chrome 中會看到主控台印出一大堆屬性。
var object = new Object(); alert(object.username); // undefined object.username = "zhangsan"; alert(object.username); // zhangsan object["password"] = "123"; alert(object.password); // 123 delete object.username; // 刪除屬性 alert(object.username); // undefined
var object = {
username: "zhangsan",
password: 12345
};
alert(object.username);
alert(object.password);
// 方法一 var array = new Array(); array.push(1); array.push(2); array.push(3); alert(array.length); // 方法二(推薦) var array = [1, 25, 4]; array.sort(); alert(array);
這裡會印出 1、25、4,並非我們期待的結果。原因是 sort() 預設會先將元素轉成字串(呼叫 toString()),再依字串順序排序。
要按數值大小排序,必須傳入比較函式:
function compare(num1, num2) {
var temp1 = parseInt(num1);
var temp2 = parseInt(num2);
if (temp1 < temp2) {
return -1;
} else if (temp1 == temp2) {
return 0;
} else {
return 1;
}
}
var array = [1, 25, 3];
array.sort(compare);
alert(array);
用匿名函式寫成更簡潔的形式:
var array = [1, 25, 3];
array.sort(function (num1, num2) {
var temp1 = parseInt(num1);
var temp2 = parseInt(num2);
if (temp1 < temp2) {
return -1;
} else if (temp1 == temp2) {
return 0;
} else {
return 1;
}
});
alert(array);
實務上,若確定元素都是數字,array.sort((a, b) => a - b) 就足夠了。
JavaScript 沒有類的概念,只有物件。以下五種方式由簡至繁。
var object = new Object();
object.name = "zhangsan";
object.sayName = function (name) {
this.name = name;
alert(this.name);
};
object.sayName("kyle"); // 印出 kyle
最簡單的一種,使用起來不太方便,適合臨時需要一個物件的情況。
不帶參數的版本:
function createObject() {
var object = new Object();
object.name = "zhangsan";
object.password = "123";
object.get = function () {
alert(this.name + "," + this.password);
};
return object;
}
var object1 = createObject();
var object2 = createObject();
object1.get();
object2.get();
帶參數的版本:
function createObject(name, password) {
var object = new Object();
object.name = name;
object.password = password;
object.get = function () {
alert(this.name + "," + this.password);
};
return object;
}
var object1 = createObject("zhangsan", "123");
var object2 = createObject("lisi", "456");
object1.get();
object2.get();
兩者的缺點相同:每建立一個物件,記憶體中就多一份 get 方法,不僅浪費空間也影響效能。但我們真正想要的是「屬性各自獨立、方法彼此共用」。改進方式是把方法提到外面:
function get() {
alert(this.name + "," + this.password);
}
function createObject(name, password) {
var object = new Object();
object.name = name;
object.password = password;
object.get = get; // 共用同一個函式物件
return object;
}
var object1 = createObject("zhangsan", "123");
var object2 = createObject("lisi", "456");
object1.get();
object2.get();
不帶參數:
function Person() {
// 執行第一行前,JS 引擎會先產生一個物件
this.name = "zhangsan";
this.password = "123";
this.getInfo = function () {
alert(this.name + "," + this.password);
};
// 此處有一個隱含的 return,把先前產生的物件回傳
// 這正是它與工廠方式最大的不同
}
var p1 = new Person();
p1.getInfo();
帶參數:
function Person(name, password) {
this.name = name;
this.password = password;
this.getInfo = function () {
alert(this.name + "," + this.password);
};
}
var p1 = new Person("zhangsan", "123");
var p2 = new Person("lisi", "456");
p1.getInfo();
p2.getInfo();
prototype 是物件裡的一個屬性。
function Person() {}
Person.prototype.name = "zhangsan";
Person.prototype.password = "123";
Person.prototype.getInfo = function () {
alert(this.name + "," + this.password);
};
var p1 = new Person();
var p2 = new Person();
p1.name = "kyle"; // 物件建立後再改屬性
p1.getInfo(); // kyle,123
p2.getInfo(); // zhangsan,123
單純使用原型方式有兩個問題。第一,無法在建構函式中為屬性賦初值,只能在物件建立後再改。第二,所有實例共用原型上的屬性,若屬性是參照型別,改動會互相影響:
function Person() {}
Person.prototype.name = new Array();
Person.prototype.password = "123";
Person.prototype.getInfo = function () {
alert(this.name + "," + this.password);
};
var p1 = new Person();
var p2 = new Person();
p1.name.push("zhangsan");
p1.name.push("lisi");
p1.password = "456";
p1.getInfo(); // zhangsan,lisi,456
p2.getInfo(); // zhangsan,lisi,123
p2 的 name 陣列被 p1 的 push 改動了,這就是共用原型的副作用。
function Person() {
this.name = new Array(); // 屬性各自獨立
this.password = "123";
}
Person.prototype.getInfo = function () { // 方法共用
alert(this.name + "," + this.password);
};
var p1 = new Person();
var p2 = new Person();
p1.name.push("zhangsan");
p2.name.push("lisi");
p1.getInfo(); // zhangsan
p2.getInfo(); // lisi
屬性互不干擾,方法共用同一份,這是一種相當實用的寫法。
function Person() {
this.name = "zhangsan";
this.password = "123";
if (typeof Person.flag == "undefined") {
Person.prototype.getInfo = function () {
alert(this.name + "," + this.password);
};
Person.flag = true;
}
}
var p1 = new Person();
var p2 = new Person();
p1.getInfo();
p2.getInfo();
在建構函式中用一個旗標讓所有物件共用方法,同時每個物件擁有自己的屬性。第一次建立物件時,判斷式成立,於是掛上 getInfo 並把旗標設為 true;第二次之後判斷式為假,直接跳過。結果就是屬性互不干擾、方法共享,兼顧了兩種需求。
// 父類
function Parent(username) {
this.username = username;
this.sayHello = function () {
alert(this.username);
};
}
// 子類
function Child(username, password) {
// 這三行是關鍵
this.method = Parent;
this.method(username);
delete this.method;
this.password = password;
this.sayWorld = function () {
alert(this.password);
};
}
var p = new Parent("zhangsan");
var c = new Child("lisi", "123");
p.sayHello();
c.sayHello();
c.sayWorld();
call 是定義在 Function 物件上的方法,因此每個函式都有。它的第一個參數會被指派給函式中的 this,從第二個參數開始逐一對應形參。
function test(str) {
alert(this.name + "," + str);
}
var object = new Object();
object.name = "zhangsan";
test.call(object, "html5war"); // 把 object 指派給 this
用 call 實作繼承:
function Parent(username) {
this.username = username;
this.sayHello = function () {
alert(this.username);
};
}
function Child(username, password) {
Parent.call(this, username);
this.password = password;
this.sayWorld = function () {
alert(this.password);
};
}
var p = new Parent("zhangsan");
var c = new Child("lisi", "123");
p.sayHello();
c.sayHello();
c.sayWorld();
function Parent(username) {
this.username = username;
this.sayHello = function () {
alert(this.username);
};
}
function Child(username, password) {
Parent.apply(this, new Array(username));
this.password = password;
this.sayWorld = function () {
alert(this.password);
};
}
var p = new Parent("zhangsan");
var c = new Child("lisi", "123");
p.sayHello();
c.sayHello();
c.sayWorld();
apply 與 call 的差別只有一點:apply 的第二個參數是陣列,而 call 傳的是離散的參數。哪個比較好取決於場景——參數數量固定時用 call 更直觀,參數來源本身就是陣列時用 apply 更省事。
function Parent() {}
Parent.prototype.hello = "hello";
Parent.prototype.sayHello = function () {
alert(this.hello);
};
function Child() {}
Child.prototype = new Parent();
Child.prototype.world = "world";
Child.prototype.sayWorld = function () {
alert(this.world);
};
var c = new Child();
c.sayHello();
c.sayWorld();
缺點是無法在建構時傳入參數,只能等物件建立完成後再去修改。
function Parent(hello) {
this.hello = hello;
}
Parent.prototype.sayHello = function () {
alert(this.hello);
};
function Child(hello, world) {
Parent.call(this, hello); // 借用建構函式傳參
this.world = world;
}
Child.prototype = new Parent(); // 原型鏈
Child.prototype.sayWorld = function () {
alert(this.world);
};
var c = new Child("hello", "world");
c.sayHello();
c.sayWorld();
用 call 解決「無法傳參」的問題,用原型鏈解決「方法無法共用」的問題,兩者互補。這正是組合繼承的核心思路,也是 ES6 之前最實用的繼承寫法。
把這 18 個重點整理成一份對照表,基本就涵蓋了 JavaScript 面試中關於變數、型別、物件與繼承的絕大部分考點。