以下整理 25 道面試中常見的 JavaScript 題目,每題附上解析與可驗證的程式碼。
問題很明顯:
let obj = {}; let arr = []; console.log(typeof obj === 'object'); //true console.log(typeof arr === 'object'); //true console.log(typeof null === 'object'); //true
陣列與 null 都會被判定為 object。改用 Object.prototype.toString.call() 可以精確判斷:
let obj = {}; let arr = []; console.log(Object.prototype.toString.call(obj)); //[object Object] console.log(Object.prototype.toString.call(arr)); //[object Array] console.log(Object.prototype.toString.call(null)); //[object Null]
另外請遠離 ==,它會做型別轉換而導致各種反直覺結果,而 [] === false 是 false。

(function(){ var a = b = 3; })(); console.log("a defined? " + (typeof a !== 'undefined')); console.log("b defined? " + (typeof b !== 'undefined'));
拆解 var a = b = 3 相當於先執行 b = 3,再 var a = b。 b 沒有宣告,成了全域變數;a 則被 var 宣告為 IIFE 內的區域變數,函數外取不到。
var myObject = { foo: "bar", func: function() { var self = this; console.log("outer func: this.foo = " + this.foo); console.log("outer func: self.foo = " + self.foo); (function() { console.log("inner func: this.foo = " + this.foo); console.log("inner func: self.foo = " + self.foo); }()); } }; myObject.func();
前兩個輸出是 bar。第三個會報錯,因為 IIFE 是獨立的作用域,其中的 this 指向全域物件(嚴格模式下是 undefined),取不到 foo。第四個輸出 bar,因為 self 透過閉包存住了外層的 this。解法是把 self 當參數傳進去:
(function(test) { console.log("inner func: this.foo = " + test.foo); //'bar' console.log("inner func: self.foo = " + self.foo); }(self));
兩個經典場景。一是迴圈中閉包捕獲變數的問題:
for(var i = 0; i < 5; i++) { setTimeout(function() { console.log(i); }, 1000); }
輸出全部是 5,因為迴圈早已結束、i 已變成 5。用 IIFE 傳值即可:
for(var i = 0; i < 5; i++) { (function(i) { setTimeout(function() { console.log(i); }, 1000); })(i) }
(用 let 宣告 i 也能直接解決,因為 let 有區塊作用域。)二是外掛與模組開發中避免全域污染:
(function($) { //代碼 } )(jQuery);
消除一些不合理、不嚴謹的語法行為;杜絕部分不安全寫法;讓引擎更容易優化以提升效能;為未來的新版本語法預留空間。
function foo1() { return { bar: "hello" }; } function foo2() { return { bar: "hello" }; }
程式碼裡兩者看起來一模一樣,但如果 foo2 的 return 後面直接換行,就不一樣了。JavaScript 的分號自動插入機制在 return、break、continue 後若遇到換行,會補上一個分號:
function foo2() { return; { bar: "hello" }; }
於是 foo2 回傳 undefined。這也是為什麼寫 return 時,同一行的 { 不能換行。
NaN 是 Not a Number 的縮寫,是 JavaScript 的一種特殊數值,其型別是 number。用 isNaN(param) 判斷:
console.log(isNaN(NaN)); //true console.log(isNaN(23)); //false console.log(isNaN('ds')); //true console.log(isNaN('32131sdasd')); //true console.log(NaN === NaN); //false console.log(NaN === undefined); //false console.log(typeof NaN); //number console.log(Object.prototype.toString.call(NaN)); //[object Number]
注意 NaN 與任何值都不相等,包括它自己。ES6 提供了 Number.isNaN(),它不進行型別轉換,判斷更嚴謹。
console.log(0.1 + 0.2); //0.30000000000000004 console.log(0.1 + 0.2 == 0.3); //false
JavaScript 的 number 採用 IEEE-754 雙精度浮點數,每個數佔 64 位。二進位無法精準表示 0.1,它是 0.0001100110011……(0011 無限循環),0.2 同理。相加後因 52 位尾數限制被截斷,轉回十進位就成了 0.30000000000000004。
常見解法有兩種。先放大再縮回:
function add(num1, num2){ let r1, r2, m; r1 = (''+num1).split('.')[1].length; r2 = (''+num2).split('.')[1].length; m = Math.pow(10,Math.max(r1,r2)); return (num1 * m + num2 * m) / m; } console.log(add(0.1,0.2)); //0.3 console.log(add(0.15,0.2256)); //0.3756
或使用 toFixed()(注意回傳的是字串)。金額計算建議直接用十進位運算庫。
function isInteger(x) { return parseInt(x, 10) === x; }
ES6 已提供 Number.isInteger()。另外 JavaScript 能精準表示的整數範圍是 -2^53 到 2^53 之間(不含端點),超出就會失真,對此可用 Number.MAX_SAFE_INTEGER 與 Number.isSafeInteger() 判斷。
(function() { console.log(1); setTimeout(function(){console.log(2)}, 1000); setTimeout(function(){console.log(3)}, 0); console.log(4); })();
輸出 1、4、3、2。JavaScript 是單執行緒,靠事件迴圈調度:同步程式碼先跑完(1 和 4),接著清空詐列,即使延遲設為 0 的定時器也要等下一輪,因此 3 先於 2。
function isPalindrome(str) { str = str.replace(/\W/g, '').toLowerCase(); return (str == str.split('').reverse().join('')); }
function sum() { var fir = arguments[0]; if(arguments.length === 2) { return arguments[0] + arguments[1] } else { return function(sec) { return fir + sec; } } }
依傳入參數個數決定「直接相加」或「回傳一個等待第二個參數的函數」,是柯里化的簡化版。
for (var i = 0; i < 5; i++) { var btn = document.createElement('button'); btn.appendChild(document.createTextNode('Button ' + i)); btn.addEventListener('click', function(){ console.log(i); }); document.body.appendChild(btn); }
點任何一個按鈕都輸出 5,原因同第 4 題,解法也一樣(IIFE 或 let)。
var arr1 = "john".split(''); // j o h n var arr2 = arr1.reverse(); // n h o j var arr3 = "jones".split(''); // j o n e s arr2.push(arr3); console.log("array 1: length=" + arr1.length + " last=" + arr1.slice(-1)); console.log("array 2: length=" + arr2.length + " last=" + arr2.slice(-1));
關鍵是 reverse() 會「原地」修改陣列並回傳同一個參照,所以 arr1 與 arr2 指向同一個物件。push 進去的是一個陣列而非元素,因此 length 只加 1。
console.log(1 + "2" + "2"); console.log(1 + +"2" + "2"); console.log(1 + -"1" + "2"); console.log(+"1" + "1" + "2"); console.log( "A" - "B" + "2"); console.log( "A" - "B" + 2);
三個規則:數字與數字字串混合運算時結果與運算元位置有關;數字字串前加上正負號會被轉為數字;運算結果無法轉為數字時回傳 NaN。
console.log(2 + 1 + '3'); //'33' console.log('3' + 2 + 1); //'321' console.log(typeof '3'); // string console.log(typeof +'3'); //number console.log('a' * 'sd'); //NaN console.log('A' - 'B'); // NaN

var list = readHugeList(); var nextListItem = function() { var item = list.pop(); if (item) { // process the list item... nextListItem(); } };
把遞迴改為用 setTimeout 打斷呼叫鏈:
var list = readHugeList(); var nextListItem = function() { var item = list.pop(); if (item) { // process the list item... setTimeout( nextListItem, 0); } };
原理同第 10 題:每次呼叫都在新的任務中執行,呼叫堆疊得以清空。
有權訪問另一個函數作用域中變數的函數。它讓函數即使在建立它的外層函數返回之後,仍能存取和修改那些變數,因此常用來實現私有變數、函數工廠與模組模式。
for (var i = 0; i < 5; i++) { setTimeout(function() { console.log(i); }, i * 1000 ); }
依秒輸出 5、5、5、5、5。解法同第 4 題。
console.log("0 || 1 = "+(0 || 1)); console.log("1 || 2 = "+(1 || 2)); console.log("0 && 1 = "+(0 && 1)); console.log("1 && 2 = "+(1 && 2));
&& 與 || 回傳的是運算元本身而非布林值,且都是短路運算。&& 回傳第一個為 false 的運算元,若皆為真則回傳最後一個;|| 回傳第一個為 true 的運算元,若皆為假則回傳最後一個。
console.log(1 && 2 && 0); //0 console.log(1 && 0 && 1); //0 console.log(1 && 2 && 3); //3 console.log(1 || 2 || 0); //1 console.log(0 || 2 || 1); //2 console.log(0 || 0 || false); //false console.log(1 && 2 || 0); //2 console.log(0 || 2 && 1); //1
常見的 falsy 值有 0、'0'、+0、-0、false、''、null、undefined、NaN。注意空陣列與空物件都是 truthy:
console.log([] == false) //true console.log({} == false) //false console.log(Boolean([])) //true console.log(Boolean({})) //true
[] == false 之所以是 true,是因為 == 會把兩邊都轉成數字:[] 轉為 '' 再轉為 0,false 轉為 0。這正是應該避免 == 的原因。

前者為 true(型別不同,會轉換後比較),後者為 false(型別不同直接判假)。
var a={}, b={key:'b'}, c={key:'c'}; a[b]=123; a[c]=456; console.log(a[b]);
輸出 456。物件的鍵只能是字串,b 與 c 都被轉為 "[object Object]",實際上是同一個鍵,第二次賦值覆蓋了第一次。
console.log((function f(n){return ((n > 1) ? n * f(n-1) : n)})(10));
結果是 10 的階乘。這裡用到了具名函數表達式,函數名稱 f 在函數體內部可見,因此能遞迴呼叫自己。

(function(x) { return (function(y) { console.log(x); })(2) })(1);
輸出 1。內層函數透過閉包訪問外層的參數 x。
var hero = { _name: 'John Doe', getSecretIdentity: function (){ return this._name; } }; var stoleSecretIdentity = hero.getSecretIdentity; console.log(stoleSecretIdentity()); console.log(hero.getSecretIdentity());
第一個輸出 undefined。把方法指派給另一個變數後呼叫,等於以全域環境作為 this,取不到 _name。若要修正,可用 call、apply 或 bind 改寫 this 指向:
var stoleSecretIdentity = hero.getSecretIdentity.bind(hero);
第二個是作為物件方法呼叫,this 正確指向 hero,輸出 John Doe。
函數接收 DOM 元素與回呼函數兩個參數,用深度優先搜尋遞迴走訪:
function Traverse(p_element,p_callback) { p_callback(p_element); var list = p_element.children; for (var i = 0; i < list.length; i++) { Traverse(list[i],p_callback); // recursive call } }
使用 children 而非 childNodes,可避免把文字節點也納入;若只需走訪後代而不含自身,把第一行 p_callback 呼叫移到迴圈之前即可。