這篇文章收集了一批短、實用、能立刻用在工作上的 JavaScript 技巧,涵蓋效能、語法 hack、面試常見題,以及 ES6 之後的新語法。每一則都附上可驗證的程式碼,建議邊看邊貼進 console 跑一次。
== 會先把兩邊轉成同一型別再比較,=== 不會——它同時比型別與值,因此更嚴謹。
[10] == 10 // true [10] === 10 // false "10" == 10 // true "10" === 10 // false [] == 0 // true [] === 0 // false "" == false // true 但是 true == "a" 是false "" === false // false
把字串轉成數字,最快的方式是用 +:
var one = '1'; var numberOne = +one; // Number 1
用 - 也可以,順便變成負數:
var one = '1'; var negativeNumberOne = -one; // Number -1
常見做法是重新指派一個空陣列:
var list = [1, 2, 3, 4]; function empty() { //清空數組 list = []; } empty();
但效能更好的寫法是改 length:
var list = [1, 2, 3, 4]; function empty() { //清空數組 list.length = 0; } empty();
差別在於:list = [] 只是把變數指向新陣列,其他仍持有舊陣列的參考完全不受影響,於是舊內容留在記憶體裡造成浪費;list.length = 0 則是真正把內容清掉。不過要注意,如果有其他變數參考同一個陣列,用 length = 0 會連那些參考一起清空:
var foo = [1,2,3]; var bar = [1,2,3]; var foo2 = foo; var bar2 = bar; foo = []; bar.length = 0; console.log(foo, bar, foo2, bar2); //[] [] [1, 2, 3] []
function shuffle(arr) { var i, j, temp; for (i = arr.length - 1; i > 0; i--) { j = Math.floor(Math.random() * (i + 1)); temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } return arr; };
使用:
var a = [1, 2, 3, 4, 5, 6, 7, 8]; var b = shuffle(a); console.log(b); // [2, 7, 8, 6, 5, 3, 1, 4]
讓方法回傳 this,呼叫就能一路串下去:
function Person(name) { this.name = name; this.sayName = function() { console.log("Hello my name is: ", this.name); return this; }; this.changeName = function(name) { this.name = name; return this; }; } var person = new Person("John"); person.sayName().changeName("Timmy").sayName(); //Hello my name is: John //Hello my name is: Timmy
當變數型別未知時,+ 可能會先做加法才拼接:
var one = 1; var two = 2; var three = '3'; var result = one + two + three; //"33" 而不是 "123"
改用 concat 就一定是字串相接:
var one = 1; var two = 2; var three = '3'; var result = ''.concat(one, two, three); //"123"
效能上 join 與 concat 幾乎相同。
單一 ~ 會把輸入轉成 −(輸入+1),因此兩個 ~~ 就變成 −(−(輸入+1)),效果是「向零取整」:正數等同 Math.floor,負數等同 Math.ceil;若無法轉成數字則回傳 0,而不是 NaN。
// 單位移 console.log(~1337) // -1338 // 雙位移 console.log(~~47.11) // -> 47 console.log(~~-12.88) // -> -12 console.log(~~1.9999) // -> 1 console.log(~~3) // -> 3 //失敗的情況 console.log(~~[]) // -> 0 console.log(~~NaN) // -> 0 console.log(~~null) // -> 0 //大於32位整數則失敗 console.log(~~(2147483647 + 1) === (2147483647 + 1)) // -> 0
雖然可能快一點,但為了可讀性,正式程式碼還是建議用 Math.floor()。
if (!module.parent) { // 運行 `node something.js` app.listen(8088, function() { console.log('app listening on port 8088'); }) } else { // 使用 `require('/.something.js')` module.exports = app; }
預設情況下沒辦法直接傳參數給回呼:
function callback() { console.log('Hi human'); } document.getElementById('someelem').addEventListener('click', callback);
利用閉包「回傳一個函式」的特性就行了:
function callback(a, b) { return function() { console.log('sum = ', (a+b)); } } var x = 1, y = 2; document.getElementById('someelem').addEventListener('click', callback(x, y));
閉包指的是「記得自己被建立時所處環境的函式」,所以回呼被觸發時,x 與 y 仍然存在於其作用域中。另一種寫法是用 bind:
var alertText = function(text) { alert(text); }; document.getElementById('someelem').addEventListener('click', alertText.bind(this, 'hello'));
原生 JS 沒有 contains,一般會寫:
var someText = 'JavaScript rules'; if (someText.indexOf('JavaScript') !== -1) { } // 或者 if (someText.indexOf('JavaScript') >= 0) { }
但 ExpressJS 的原始碼裡常見這種寫法:
// examples/mvc/lib/boot.js for (var key in obj) { // "reserved" exports if (~['name', 'prefix', 'engine', 'before'].indexOf(key)) continue; // examples/lib/utils.js exports.normalizeType = function(type){ return ~type.indexOf('/') ? acceptParams(type) : { value: mime.lookup(type), params: {} }; }; // examples/web-service/index.js // key is invalid if (!~apiKeys.indexOf(key)) return next(error(401, 'invalid api key'));
原理是 ~ 會把 −1 變成 0,而 0 在 JS 裡是 falsy:
var someText = 'text'; !!~someText.indexOf('tex'); // someText 包含 "tex" - true !~someText.indexOf('tex'); // someText 不包含 "tex" - false ~someText.indexOf('asd'); // someText 不包含 "asd" - false ~someText.indexOf('ext'); // someText 包含 "ext" - true
ES6 之後有了更清楚的 includes():
'something'.includes('thing'); // true
ES2016 起陣列也支援:
[1, 2, 3].includes(1); // true
不過這些新方法在舊瀏覽器(IE 全系)上並不支援,仍要注意相容性。
箭頭函數的好處有兩個:語法短、this 從上下文繼承。
// arrow函數的日常語法 param => expression // 可能也會寫在括號中 // 括號是多參數要求 (param1 [, param2]) => expression // 使用日常函數 var arr = [5,3,2,9,1]; var arrFunc = arr.map(function(x) { return x * x; }); console.log(arr) // 使用arrow函數 var arr = [5,3,2,9,1]; var arrFunc = arr.map((x) => x*x); console.log(arr)
而 this 的問題更值得說明。以下四個計數器做的是同一件事:
// 全局定義this.i this.i = 100; var counterA = new CounterA(); var counterB = new CounterB(); var counterC = new CounterC(); var counterD = new CounterD(); // 不好的示例 function CounterA() { // CounterA's `this` 實例 (!! 忽略這裡) this.i = 0; setInterval(function () { // `this` 指全局對象,而不是 CounterA's `this` // 因此,開始計數與100,而不是0 (本地的 this.i) this.i++; document.getElementById("counterA").innerHTML = this.i; }, 500); } // 手動綁定 that = this function CounterB() { this.i = 0; var that = this; setInterval(function() { that.i++; document.getElementById("counterB").innerHTML = that.i; }, 500); } // 使用 .bind(this) function CounterC() { this.i = 0; setInterval(function() { this.i++; document.getElementById("counterC").innerHTML = this.i; }.bind(this), 500); } // 使用 arrow函數 function CounterD() { this.i = 0; setInterval(() => { this.i++; document.getElementById("counterD").innerHTML = this.i; }, 500); }
CounterA 的 this 指向全域物件,CounterB 用 that = this 繞過,CounterC 用 bind(this),而 CounterD 用箭頭函數直接繼承外層的 this——這是最乾淨的寫法。
console.time("Array initialize"); var arr = new Array(100), len = arr.length, i; for (i = 0; i < len; i++) { arr[i] = new Object(); }; console.timeEnd("Array initialize"); // 輸出: Array initialize: 0.711ms
JS 的每個參數都是可選的,但可以透過預設值加上一點技巧,強制要求必填:
const _err = function( message ){ throw new Error( message ); } const getSum = (a = _err('a is not defined'), b = _err('b is not defined')) => a + b getSum( 10 ) // throws Error, b is not defined getSum( undefined, 10 ) // throws Error, a is not defined
變數宣告與函式宣告會被提升到作用域頂端,但賦值不會:
function doTheThing() { // 錯誤: notDeclared is not defined console.log(notDeclared); // 輸出: undefined console.log(definedLater); var definedLater; definedLater = 'I am defined!' // 輸出: 'I am defined!' console.log(definedLater) // Outputs: undefined console.log(definedSimulateneously); var definedSimulateneously = 'I am defined!' // 輸出: 'I am defined!' console.log(definedSimulateneously) // 輸出: 'I did it!' doSomethingElse(); function doSomethingElse(){ console.log('I did it!'); } // 錯誤: undefined is not a function functionVar(); var functionVar = function(){ console.log('I did it!'); } }
實務建議:在使用變數之前就宣告它們,並把函式定義放在作用域尾端,讓程式碼更容易讀。
一般會直接寫 if (myObject.name),但這有兩個盲點:屬性存在但值為 falsy 時會誤判,以及繼承來的方法也會被算進去。更精確的做法有兩種:
var myObject = { name: '@tips_js' }; myObject.hasOwnProperty('name'); // true 'name' in myObject; // true myObject.hasOwnProperty('valueOf'); // false, valueOf 是從原型鏈繼承的 'valueOf' in myObject; // true
差別就在於:hasOwnProperty 只認「物件自身」的屬性,in 則連原型鏈上的也算。再舉一例:
var myFunc = function() { this.name = '@tips_js'; }; myFunc.prototype.age = '10 days'; var user = new myFunc(); user.hasOwnProperty('name'); // true user.hasOwnProperty('age'); // false, 因為age是原型鏈上的
普通字串拼接:
var firstName = 'Jake'; var lastName = 'Rawr'; console.log('My name is ' + firstName + ' ' + lastName); // My name is Jake Rawr
模板字面值:
var firstName = 'Jake'; var lastName = 'Rawr'; console.log(`My name is ${firstName} ${lastName}`); // My name is Jake Rawr
在 ${} 裡可以放任何運算式,也能直接跨行撰寫,不必再拼 \n。此外還可以自訂「標籤函式」來修改輸出結果。
querySelectorAll 回傳的是類陣列物件,沒有 map、forEach 這些方法。用 apply 可以安全轉換:
const nodelist = document.querySelectorAll('div'); const nodelistToArray = Array.apply(null, nodelist); //later on .. nodelistToArray.forEach(...); nodelistToArray.map(...); nodelistToArray.slice(...); //etc...
若能用 ES2015,展開運算子更直觀:
const nodelist = [...document.querySelectorAll('div')]; // 返回的是個真實的數組 //later on .. nodelist.forEach(...); nodelist.map(...); nodelist.slice(...); //etc...
預設情況下 JS 允許你用未宣告的變數,這看似方便,卻是拼字錯誤與變數外洩的主要來源。嚴格模式會把這些行為變成明確的錯誤。
放在檔案最前面,整個檔案都進入嚴格模式:
// 整個script文件都將是嚴格模式語法 "use strict"; var v = "Hi! I'm a strict mode script!";
或者只放在函式內:
function f() { // 函數范圍內的嚴格模式語法 'use strict'; function nested() { return "And so am I!"; } return "Hi! I'm a strict mode function! " + nested(); } function f2() { return "I'm not strict."; }
嚴格模式主要禁止了:未宣告就使用變數、寫入唯讀屬性、不用 new 呼叫建構函式、this 預設指向全域、以及寬鬆使用 eval() 與保留字。
支援情況:IE 10+、Firefox 4+、Chrome 13+、Safari 5.1+、Opera 12+。要注意的是它是字面值而非宣告,舊瀏覽器會直接忽略;另外在多檔合併的建置流程中,一個檔案寫了 use strict 可能讓合併後的整份程式都變成嚴格模式,這點要特別小心。
不必為「傳一個」和「傳一組」各寫一個方法,用 concat 統一處理就好:
function printUpperCase(words) { var elements = [].concat(words); for (var i = 0; i < elements.length; i++) { console.log(elements[i].toUpperCase()); } }
於是兩種呼叫都能work:
printUpperCase("cactus"); // => CACTUS printUpperCase(["cactus", "bear", "potato"]); // => CACTUS // BEAR // POTATO
· undefined 代表變數未宣告,或已宣告但未賦值
· null 是一個明確的「沒有值」的值
· JS 會自動把未賦值的變數設為 undefined,不會設成 null;null 是設計師用來表達「刻意留空」的
· undefined 不是合法的 JSON 值,null 是
· typeof undefined 是 "undefined";typeof null 卻是 "object"(這是 JS 的歷史 bug)
· 兩者都是 falsy:Boolean(undefined) // false、Boolean(null) // false
判斷方式:
typeof variable === "undefined"
variable === null
而兩者的比較結果容易讓人誤會:
null == undefined // true
null === undefined // false
array.sort() 預設依 UTF-16 碼點排序,對英文沒問題:
['Shanghai', 'New York', 'Mumbai', 'Buenos Aires'].sort(); // ["Buenos Aires", "Mumbai", "New York", "Shanghai"]
但遇到帶重音的歐洲語言就會出錯:
// Spanish ['único','árbol', 'cosas', 'fútbol'].sort(); // ["cosas", "fútbol", "árbol", "único"] // 錯誤的排序 // German ['Woche', 'wöchentlich', 'wäre', 'Wann'].sort(); // ["Wann", "Woche", "wäre", "wöchentlich"] // 錯誤的排序
解法有兩個。用 localeCompare():
['único','árbol', 'cosas', 'fútbol'].sort(function (a, b) { return a.localeCompare(b); }); // ["árbol", "cosas", "fútbol", "único"] ['Woche', 'wöchentlich', 'wäre', 'Wann'].sort(function (a, b) { return a.localeCompare(b); }); // ["Wann", "wäre", "Woche", "wöchentlich"]
或用 Intl.Collator:
['único','árbol', 'cosas', 'fútbol'].sort(Intl.Collator().compare); // ["árbol", "cosas", "fútbol", "único"] ['Woche', 'wöchentlich', 'wäre', 'Wann'].sort(Intl.Collator().compare); // ["Wann", "wäre", "Woche", "wöchentlich"]
· 兩者都能自訂排序規則
· 在 Firefox 上處理大量資料時 Intl.Collator 明顯較快
因此只要字串不是純英文,記得改用這兩個方法。
原本的巢狀 if:
if (color) { if (color === 'black') { printBlackBackground(); } else if (color === 'red') { printRedBackground(); } else if (color === 'blue') { printBlueBackground(); } else if (color === 'green') { printGreenBackground(); } else { printYellowBackground(); } }
改成 switch 更簡潔有序,但除錯較不友善:
switch(color) { case 'black': printBlackBackground(); break; case 'red': printRedBackground(); break; case 'blue': printBlueBackground(); break; case 'green': printGreenBackground(); break; default: printYellowBackground(); }
若每個分支都是多條件判斷,可以把 true 當參數傳給 switch:
switch(true) { case (typeof color === 'string' && color === 'black'): printBlackBackground(); break; case (typeof color === 'string' && color === 'red'): printRedBackground(); break; case (typeof color === 'string' && color === 'blue'): printBlueBackground(); break; case (typeof color === 'string' && color === 'green'): printGreenBackground(); break; case (typeof color === 'string' && color === 'yellow'): printYellowBackground(); break; }
但最推薦的其實是用物件做查表,簡潔又高效:
var colorObj = { 'black': printBlackBackground, 'red': printRedBackground, 'blue': printBlueBackground, 'green': printGreenBackground, 'yellow': printYellowBackground }; if (color in colorObj) { colorObj[color](); }
key 是傳給動態清單中每個元件用的唯一識別碼,React 靠它判斷哪些元件是同一個、哪些是新產生的。少了它或寫錯,會導致元件被重複建立、狀態錯亂等怪現象。
· 使用資料本身已經存在的唯一值
· 在父元件定義 key,而不是在子元件內部
//不好的 ... render() { <div key={item.key}>{item.name}</div> } ... //好的 <MyComponent key={item.key}/>
· 不要用陣列索引當 key
· 不要用 Math.random()——每次 render 都變,等於永遠是新元件
//不好的 <MyComponent key={Math.random()}/>
· 若沒有現成 id,請自行產生一個,並確保方法夠快
· 當子元件數量龐大或結構複雜時,正確的 key 對效能影響顯著
· ReactCSSTransitionGroup 的所有子元件都必須提供 key
雙向資料綁定是 AngularJS 最迷人的特性,而它之所以能運作,是因為框架會不斷評估「模型變了沒、視圖要不要更新」——這個循環就叫 $digest。理解它,才能理解框架在背後做什麼,也才能避免自己踩到效能地雷。
$apply
這個方法會啟動一整輪 $digest:所有 watch 都會被檢查,整個應用程式進入消化循環。它在內部會先執行你傳入的函式,接著呼叫 $rootScope.$digest()。
$digest
這個方法只在當前作用域及其子作用域執行,父作用域不受影響,因此範圍更小、成本更低。
建議:
· 只在 Angular 之外的 DOM 事件觸發時才手動呼叫 $apply 或 $digest
· 傳函式表達式給 $apply,這樣才有錯誤處理機制
$scope.$apply(() => { $scope.tip = 'Javascript Tip'; });
· 若只需更新當前作用域,用 $digest 可避免整份應用一起消化,效能差很多
· 綁定量很大時,$apply 可能造成明顯效能問題
· Angular 1.2.x 以上可用 $evalAsync,它會在當前或下一輪循環中評估表達式,有助於改善效能
在尾端追加,push 之外還有更快的寫法:
var arr = [1,2,3,4,5]; arr.push(6); arr[arr.length] = 6; //在Chrome 47.0.2526.106 (Mac OS X 10.11.1)上提高了 43% 的速度
在開頭插入:
var arr = [1,2,3,4,5]; arr.unshift(0); [0].concat(arr); //在Chrome 47.0.2526.106 (Mac OS X 10.11.1)上提高了 98% 的速度
差別在於 unshift 會修改原陣列,concat 則回傳新陣列。
插入到中間,splice 是最有效率的方式:
var items = ['one', 'two', 'three', 'four']; items.splice(items.length / 2, 0, 'hello');
這些數據在不同瀏覽器與作業系統上的結果大致相似。不過要提醒的是:效能數據會隨引擎版本大幅變動,上面引用的數字反映的是當時的 Chrome 版本,今天的差異可能完全不同。與其記住結論,不如養成自己跑一次 jsPerf 的習慣——那才是真正可靠的依據。