以下是我平日積累的一些 JavaScript 小技巧,涵蓋型別轉換、陣列操作、環境判斷與幾個容易寫錯的細節。
var myVar = "3.14159", str = "" + myVar, // 轉字串 int = ~~myVar, // 轉整數 float = 1 * myVar, // 轉浮點數 bool = !!myVar, // 轉布林(非空字串與非 0 數字皆為 true) array = [myVar]; // 轉陣列
但轉日期 new Date(myVar) 與轉正則表達式 new RegExp(myVar) 必須使用建構函式,只有正則有 /pattern/flags 這種字面簡化寫法。
字串參與運算時 JavaScript 會自動轉為數值(無法轉就變成 NaN):
'10.567890' | 0 // 10 '10.567890' ^ 0 // 10 -2.23456789 | 0 // -2 ~~-2.23456789 // -2
原理是:JavaScript 的數值都是雙精度浮點數,因此進行位元運算時會先轉為整數。| 是位元或,x | 0 永遠等於 x;^ 是互斥或,同 0 異 1,所以 x ^ 0 也等於 x;~ 是按位取反,做兩次自然回到原值。要注意的是這個技巧會把整數截斷(不是四捨五入),且只適用於 32 位元範圍內的數字,超出會溢出。
JavaScript 內部對時間的表示就是 Unix 時間戳,以毫秒為單位記錄距 1970-01-01 00:00 的距離:
var d = +new Date(); // 1295698416792
var arr = [].slice.call(arguments);
在函式裡想把「前面幾個固定參數 + 其餘全部」合併成一個陣列:
function test() {
var res = ['item1', 'item2'];
res = res.concat(Array.prototype.slice.call(arguments)); // 方法一
Array.prototype.push.apply(res, arguments); // 方法二
}
(12).toString(16); // "c",轉十六進位
(12).toString(8); // "14",轉八進位
parseInt("FF", 16); // 255
parseInt("20", 8); // 16
var a = [1, 2, 3, 7, 8, 9]; var b = [4, 5, 6]; var insertIndex = 3; a.splice.apply(a, Array.prototype.concat(insertIndex, 0, b)); // a 變成 [1, 2, 3, 4, 5, 6, 7, 8, 9]
splice 的第二個參數是 0,代表「不刪除、只插入」,這是插入而非替換的關鍵。
var a = [1, 2, 3, 4, 5]; a.splice(3, 1); // a = [1, 2, 3, 5]
為什麼不用 delete?因為 delete 會在陣列中留下空洞,後面的索引也不會遞減,length 更不會改變。要維持連續的序列,splice 是唯一正確的選擇。
var ie = /*@cc_on !@*/false;
還有更多寫法:
// 利用 IE 不忽略陣列末尾逗號(非標準行為) var ie = !-[1,]; // 利用條件編譯註解 var ie = /*@cc_on!@*/false; var ie = /*@cc_on=1; @*/ 0; // IE 不支援垂直定位符 var ie = '\v' == 'v'; var ie = !+"\v1";
這些技巧有趣,但僅供理解原理。實務上判斷瀏覽器應該用功能偵測(例如 'addEventListener' in window),而不是判斷品牌——前者問「你做不做得到」,後者問「你是誰」,而問「你是誰」向來不可靠。
找一組數字的最大值,可能會寫成這樣:
var numbers = [3, 342, 23, 22, 124];
var max = 0;
for (var i = 0; i < numbers.length; i++) {
if (numbers[i] > max) { max = numbers[i]; }
}
alert(max);
排序後取第一個也可以:
numbers.sort(function (a, b) { return b - a; });
alert(numbers[0]);
但最簡潔的是原生方法:
Math.max(12, 123, 3, 2, 433, 4); // 433 Math.max.apply(Math, [12, 123, 3, 2, 433, 4]); Math.min.apply(Math, [12, 123, 3, 2, 433, 4]);
要注意 apply 是把陣列展開成「多個參數」,因此陣列很長時(通常超過六、七萬項)會超出引擎的參數數量上限而拋錯。大量資料時還是得用迴圈或 reduce。
Math.random().toString(16).substring(2); Math.random().toString(36).substring(2);
toString 的參數是基底,範圍 2 到 36。用 36 進位能湊出英文與數字的組合,常被拿來做簡易的隨機 ID。
a = [b, b = a][0];
ES6 之後有更清楚的寫法:[a, b] = [b, a];
HTML:
<h2>Great Web resources</h2> <ul id="resources"> <li><a href="https://opera.com/wsc">Opera Web Standards Curriculum</a></li> <li><a href="https://sitepoint.com">Sitepoint</a></li> <li><a href="https://alistapart.com">A List Apart</a></li> <li><a href="https://yuiblog.com">YUI Blog</a></li> </ul>
傳統寫法為每個連結各綁一次:
(function () {
var resources = document.getElementById('resources');
var links = resources.getElementsByTagName('a');
var all = links.length;
for (var i = 0; i < all; i++) {
links[i].addEventListener('click', handler, false);
}
function handler(e) {
var x = e.target;
alert(x);
e.preventDefault();
}
})();
用事件委派可以寫得更優雅——只綁一次,並在回呼中判斷目標是不是我們要的:
(function () {
var resources = document.getElementById('resources');
resources.addEventListener('click', handler, false);
function handler(e) {
var x = e.target;
if (x.nodeName.toLowerCase() === 'a') {
alert('Event delegation: ' + x);
e.preventDefault();
}
}
})();
// 不好:foo 未定義時會拋錯
if (foo) { doSomething(); }
// 可行:不會報錯,但 foo 為 null 或 false 時條件仍成立
if (typeof foo != "undefined") { doSomething(); }
// 更好:以 window 上的屬性判斷
if (window.foo) { doSomething(); }
結構較深時,往往需要逐層確認:
// 冗長:必須先確認每一層物件都存在
if (window.oFoo && oFoo.oBar && oFoo.oBar.baz) {
doSomething();
}
而最乾淨的屬性存在性檢查是 in 運算子:
if ("opera" in window) {
console.log("OPERA");
} else {
console.log("NOT OPERA");
}
in 的好處是「只檢查鍵存不存在,不看值」,因此即使該屬性的值為 undefined 或 false,仍能正確判斷它已被定義。
var obj = []; Object.prototype.toString.call(obj) == "[object Array]";
ES5 之後直接用 Array.isArray(obj) 即可,這是標準且跨 frame 都正確的方法。
function doSomething() {
// 沒傳參數就直接結束
if (!arguments[0]) { return false; }
var oArgs = arguments[0],
arg0 = oArgs.arg0 || "",
arg1 = oArgs.arg1 || "",
arg2 = oArgs.arg2 || 0,
arg3 = oArgs.arg3 || [],
arg4 = oArgs.arg4 || false;
}
doSomething({ arg1: "foo", arg2: 5, arg4: false });
參數一多,用物件傳值比位置參數可讀得多,也不必記順序。ES6 的解構語法讓這件事更簡潔:function doSomething({ arg1 = "", arg2 = 0 } = {}) { ... }
var sFlop = "Flop: [Ah] [Ks] [7c]";
var aValues = { "A": "Ace", "K": "King", 7: "Seven" };
var aSuits = { "h": "Hearts", "s": "Spades", "d": "Diamonds", "c": "Clubs" };
sFlop = sFlop.replace(/\[\w+\]/gi, function (match) {
match = match.replace(match[2], aSuits[match[2]]);
match = match.replace(match[1], aValues[match[1]] + " of ");
return match;
});
// "Flop: [Ace of Hearts] [King of Spades] [Seven of Clubs]"
當替換規則無法用單一字串表達、必須依比對結果計算時,傳函式是唯一的方法。
巢狀迴圈裡想跳出某一層,不必再靠旗標變數:
outerloop: for (var iI = 0; iI < 5; iI++) {
if (somethingIsTrue()) {
break outerloop; // 跳出外層
}
innerloop: for (var iA = 0; iA < 5; iA++) {
if (somethingElseIsTrue()) {
break innerloop; // 跳出內層
}
}
}
/**
* 對陣列去重,回傳一個沒有重複元素的新陣列
*/
function unique(target) {
var result = [];
loop:
for (var i = 0, n = target.length; i < n; i++) {
for (var x = i + 1; x < n; x++) {
if (target[x] === target[i]) { continue loop; }
}
result.push(target[i]);
}
return result;
}
或用物件做查表:
Array.prototype.distinct = function () {
var newArr = [], obj = {};
for (var i = 0, len = this.length; i < len; i++) {
if (!obj[typeof (this[i]) + this[i]]) {
newArr.push(this[i]);
obj[typeof (this[i]) + this[i]] = 'new';
}
}
return newArr;
}
加 typeof 前綴是為了避免型別碰撞:數字 1 與字串 "1" 轉成鍵之後都是 "1",若不加前綴就會被誤判為重複。
若要處理物件元素的深度比較,則需要遞迴:
Array.prototype.distinct = function () {
function sameObj(a, b) {
var tag = true;
if (!a || !b) { return false; }
for (var x in a) {
if (!b[x]) { return false; }
if (typeof (a[x]) === 'object') {
tag = sameObj(a[x], b[x]);
} else {
if (a[x] !== b[x]) { return false; }
}
}
return tag;
}
var newArr = [], obj = {};
for (var i = 0, len = this.length; i < len; i++) {
if (!sameObj(obj[typeof (this[i]) + this[i]], this[i])) {
newArr.push(this[i]);
obj[typeof (this[i]) + this[i]] = this[i];
}
}
return newArr;
}
搭配比較函式使用:
var arr = [{ name: "tom", age: 12 }, { name: "lily", age: 22 }, { name: "lilei", age: 12 }];
var newArr = arr.distinct(function (ele) { return ele.age; });
ES6 之後,基本型別的去重一句話就夠了:[...new Set(arr)] 或 Array.from(new Set(arr))。物件陣列若要依某個欄位去重,則仍可搭配 filter 與 Map 來做。
var i, len, maxobj = '', maxnum = 0, obj = {};
var arr = "sdjksfssscfssdd";
for (i = 0, len = arr.length; i < len; i++) {
obj[arr[i]] ? obj[arr[i]]++ : obj[arr[i]] = 1;
if (maxnum < obj[arr[i]]) {
maxnum = obj[arr[i]];
maxobj = arr[i];
}
}
alert(maxobj + " 在字串中出現了 " + maxnum + " 次");
這裡的技巧是「邊計數邊更新最大值」,省掉了第二趟迴圈。核心思路則是用物件當計數器:鍵是字元,值是出現次數。
以上只是平日零散積累的一部分。這些技巧的價值不在於「看起來厲害」,而在於理解背後的原理——位元運算為何能取整、splice 與 delete 的差別、typeof 與 toString 各自能判斷什麼。原理清楚了,遇到新問題時自然寫得出正確的程式。