DIV CSS 佈局教程網

JavaScript 實用小技巧大全:從運算子到效能與 ES6 語法
編輯:關於JavaScript     

這篇文章收集了一批短、實用、能立刻用在工作上的 JavaScript 技巧,涵蓋效能、語法 hack、面試常見題,以及 ES6 之後的新語法。每一則都附上可驗證的程式碼,建議邊看邊貼進 console 跑一次。

#24 用 === 取代 ==

== 會先把兩邊轉成同一型別再比較,=== 不會——它同時比型別與值,因此更嚴謹。

 [10] == 10 // true [10] === 10 // false "10" == 10 // true "10" === 10 // false [] == 0 // true [] === 0 // false "" == false // true 但是 true == "a" 是false "" === false // false 

#23 更快的字串轉數字

把字串轉成數字,最快的方式是用 +:

 var one = '1'; var numberOne = +one; // Number 1 

用 - 也可以,順便變成負數:

 var one = '1'; var negativeNumberOne = -one; // Number -1 

#22 清空陣列的兩種寫法差在哪

常見做法是重新指派一個空陣列:

 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] [] 

#21 用 Fisher-Yates 洗牌演算法打乱陣列

 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] 

#20 回傳 this 就能鏈式呼叫

讓方法回傳 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 

#19 用 concat 安全拼接字串

當變數型別未知時,+ 可能會先做加法才拼接:

 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 幾乎相同。

#18 雙波浪線 ~~ 當作更快的 Math.floor

單一 ~ 會把輸入轉成 −(輸入+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()。

#17 Node.js:區分被 require 與被直接執行

 if (!module.parent) { // 運行 `node something.js` app.listen(8088, function() { console.log('app listening on port 8088'); }) } else { // 使用 `require('/.something.js')` module.exports = app; }

#16 用閉包替回呼函式傳參

預設情況下沒辦法直接傳參數給回呼:

 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')); 

#15 更簡潔的「包含」判斷

原生 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 全系)上並不支援,仍要注意相容性。

#14 ES6 箭頭函數

箭頭函數的好處有兩個:語法短、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——這是最乾淨的寫法。

#13 測量程式碼區塊的執行時間

 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 

#12 ES6 的預設參數

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 

#11 變數提升(Hoisting)

變數宣告與函式宣告會被提升到作用域頂端,但賦值不會:

 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!'); } }

實務建議:在使用變數之前就宣告它們,並把函式定義放在作用域尾端,讓程式碼更容易讀。

#10 檢查物件是否擁有某屬性

一般會直接寫 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是原型鏈上的 

#09 模板字面值

普通字串拼接:

 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。此外還可以自訂「標籤函式」來修改輸出結果。

#08 把 NodeList 轉成真陣列

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... 

#07 use strict 告別「懶惰」

預設情況下 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 可能讓合併後的整份程式都變成嚴格模式,這點要特別小心。

#06 讓函式同時接受單一元素與陣列

不必為「傳一個」和「傳一組」各寫一個方法,用 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 

#05 undefined 與 null 的差異

· 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

#04 排序含非 ASCII 字元的字串

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 明顯較快
因此只要字串不是純英文,記得改用這兩個方法。

#03 改善多層條件判斷

原本的巢狀 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](); }

#02 React 的 key 屬性很重要

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

#01 AngularJS:$digest 與 $apply 該用哪個

雙向資料綁定是 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,它會在當前或下一輪循環中評估表達式,有助於改善效能

#00 往陣列插入元素

在尾端追加,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 的習慣——那才是真正可靠的依據。

XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved