這一類文章我們分兩部分來梳理:先談面試現場最常出現的手寫題,再把 JavaScript 語言層面必須掌握的基礎概念串一遍。內容會持續補充。
讓候選人當場在白板或編輯器裡寫代碼,已經是技術面試的標配環節。它並不追求你背出多少 API,而是看你的數據結構感覺、邊界條件意識以及代碼組織能力。下面這兩題出現頻率極高。
最直白的做法:借助 indexOf 逐項比對
Array.prototype.unique = function () {
var result = [];
this.forEach(function (v) {
if (result.indexOf(v) < 0) {
result.push(v);
}
});
return result;
};
用哈希表換時間:把已出現的值記到對象上,查詢從 O(n) 降為 O(1),是典型的空間換時間。
Array.prototype.unique = function () {
var result = [], hash = {};
this.forEach(function (v) {
if (!hash[v]) {
hash[v] = true;
result.push(v);
}
});
return result;
};
但這個版本藏著一個坑。對 [1, 2, '1', '2', 3] 去重,結果會變成 [1, 2, 3]——因為對象取屬性時會做一次強制轉型,hash['1'] 和 hash[1] 命中同一個槽位。想區分開,就得把類型一起當作判斷依據:
Array.prototype.unique = function () {
var result = [], hash = {};
this.forEach(function (v) {
var type = typeof v;
hash[v] || (hash[v] = []);
if (hash[v].indexOf(type) < 0) {
hash[v].push(type);
result.push(v);
}
});
return result;
};
先排序再篩:排序後相同元素必然相鄰,只需和結果集最後一項比較即可。
Array.prototype.unique = function () {
var result = [this[0]];
this.sort();
this.forEach(function (v) {
if (v !== result[result.length - 1]) {
result.push(v);
}
});
return result;
};
版本一:不依賴數組封裝方法,手寫原地交換
function quickSort(arr) {
qSort(arr, 0, arr.length - 1);
}
function qSort(arr, low, high) {
if (low < high) {
var mid = partition(arr, low, high);
qSort(arr, low, mid - 1);
qSort(arr, mid + 1, high);
}
}
function partition(arr, low, high) {
var key = arr[low];
while (low < high) {
while (low < high && arr[high] >= key) high--;
arr[low] = arr[high];
while (low < high && arr[low] <= key) low++;
arr[high] = arr[low];
}
arr[low] = key;
return low;
}
版本二:用數組方法寫出更簡潔的表達式
function quickSort(arr) {
if (arr.length <= 1) return arr;
var index = Math.floor(arr.length / 2);
var key = arr.splice(index, 1)[0];
var left = [], right = [];
arr.forEach(function (v) {
v <= key ? left.push(v) : right.push(v);
});
return quickSort(left).concat([key], quickSort(right));
}
面試時最好順口補一句複雜度:平均 O(n log n),最壞情況出現在序列已基本有序時,退化為 O(n²);另外快排是不穩定排序。
JavaScript 的類型分成兩大類。原始類型五種:Number、String、Boolean、Null、Undefined;引用類型一種:Object。
typeof 可以返回 "number"、"string"、"boolean"、"undefined"、"object"、"function"。要注意 typeof null 的結果是 "object"。按《JavaScript 高級程序設計》的說法,這是語言最早期的實現遺留問題,後被 ECMAScript 沿用;如今普遍把 null 解釋為「對象的佔位符」,但從技術角度看它依然是原始值。
執行一段 JS 代碼(全局代碼或函數體)時,引擎會建立一個執行上下文。頁面加載後先有全局作用域,之後每進入一個函數就新增一層作用域,這些作用域串起來就是作用域鏈:鏈頭是全局作用域,鏈尾是當前函數作用域。
它的核心職責是標識符解析。函數被創建時(注意不是執行時),this、arguments、命名參數以及函數內所有局部變量都會被登記到當前作用域。當代碼需要查找變量 X,引擎從鏈尾的當前作用域開始逐層向上找,一直找到全局作用域;若仍未命中,就判定該作用域鏈上不存在 X,拋出 ReferenceError。
每個對象都有一個指向原型對象的內部引用,而原型對象自己也是對象,也有它的原型,於是一路串成原型鏈。原型鏈的終點是 Object.prototype,它的原型是 null。
原型鏈主要用於繼承。函數的 prototype 屬性是一個對象,當該函數被當作構造函數使用時,這個對象會成為所有實例的原型——我們平時調用的數組方法,正是從 Array.prototype 繼承來的。
讀取屬性時的查找順序是:先看對象自身,命中就返回;沒有則沿原型鏈一路上溯,直到根節點。全程未命中返回 undefined。只要原型上的屬性沒有被實例覆蓋,它對所有實例都是可見的。
《JavaScript 權威指南》的說法是:變量在聲明之前就已可用,這個特性被非正式地稱為「聲明提前」——函數內聲明的所有變量(不含賦值動作)都會被提到函數頂部。
var scope = "global";
function myFunc() {
console.log(scope); // undefined,而不是 "global"
var scope = "local";
}
因為局部變量 scope 的聲明被提前,此時它只完成聲明、尚未賦值,所以輸出 undefined。上面這段等價於:
var scope = "global";
function myFunc() {
var scope;
console.log(scope);
scope = "local";
}
文獻對閉包的定義往往很抽象。用一句話概括:閉包是一種讓函數能夠繼續訪問其他函數內部局部變量的語法機制。
function outFunc() {
var name = "Vicfeel";
function inFunc() {
console.log(name);
}
return inFunc;
}
var fn = outFunc();
fn(); // "Vicfeel"
外層函數執行結束後,內層函數依然握著 name 的引用,這就是閉包。
一個常見應用是模擬私有成員:
function User() {
this.name = "Vicfeel"; // 公有屬性
var age = 23; // 私有屬性
this.sayAge = function () {
console.log("my age is " + age);
};
}
var user = new User();
console.log(user.name); // "Vicfeel"
console.log(user.age); // undefined
user.sayAge(); // "my age is 23"
age 只在 sayAge 的閉包環境中可見,外部拿不到,於是實現了私有性。想深入理解的話,阮一峰老師的《學習 JavaScript 閉包》值得一讀。
function User() {
this.name = "Vicfeel";
this.age = 23;
}
var user = new User();
new 背後大致是四步:新建一個對象;把它的原型指向構造函數的 prototype;以這個新對象為 this 執行構造函數;返回該對象。
function User() {
// this = Object.create(User.prototype);
this.name = "Vicfeel";
this.age = 23;
// return this;
}
var user = new User();
補充一個細節:如果構造函數裡手動 return 一個原始類型,返回值會被忽略;如果返回的是對象,則以該對象為準。
需要給大量元素綁定同類事件時,不必逐個綁,把監聽掛到父節點上即可。
反面示範——每個 li 都綁一次:
var count = 100;
var ulList = document.getElementById("list");
for (var i = count; i--;) {
ulList.appendChild(document.createElement('li'));
}
var liNodes = ulList.getElementsByTagName("li");
for (var j = 0, l = liNodes.length; j < l; j++) {
liNodes[j].onclick = function () {
// 單個 li 的點擊邏輯
};
}
DOM 操作本身開銷不低,重複綁定無疑是性能殺手。事件代理的思路是:利用事件冒泡,只在父元素 ul 上綁一次,再透過 event.target 判斷真正被點擊的是哪個子節點。
var count = 100;
var ulList = document.getElementById("list");
for (var i = count; i--;) {
ulList.appendChild(document.createElement('li'));
}
ulList.onclick = function (e) {
var target = e.target;
if (target && target.nodeName.toUpperCase() === "LI") {
// li 的點擊邏輯
}
};
新內容會持續補充。