DIV CSS 佈局教程網

JavaScript 實用技巧彙編:型別轉換、陣列操作與常見判斷
編輯:關於JavaScript     

以下是我平日積累的一些 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 是唯一正確的選擇。

八、判斷是否為 IE

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 } = {}) { ... }

十六、為 replace 傳入函式

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 各自能判斷什麼。原理清楚了,遇到新問題時自然寫得出正確的程式。

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