DIV CSS 佈局教程網

一個能排序陣列與物件的通用函式:支援多層路徑與升降序
編輯:關於JavaScript     

JavaScript 的 Array.prototype.sort 只能處理陣列,而且預設是字串比較。若要對物件陣列依某個欄位排序,或要對物件的鍵排序,就得自己處理。本文提供一個通用函式,支援這幾種情況。

函式實作

/**
 * 排序陣列或物件
 * @param {Array|Object} object 要排序的陣列或物件
 * @param {string|string[]|number[]} subkey 排序依據的子鍵,可為單層鍵名或多層路徑
 * @param {boolean} desc 排序方式,true 為降序,false 或省略為升序
 * @returns {Array|Object} 排序後的結果
 *
 * 注意:物件的排序結果用 console.log 檢視時,鍵可能會被瀏覽器
 * 依字母順序顯示,但在 for...in 迴圈中是可正確取得排序順序的
 */
function sort_object(object, subkey, desc) {
  var is_array = Object.prototype.toString.call(object) === '[object Array]';

  // 取得排序用的鍵集合
  var keys;
  if (is_array) {
    keys = { length: object.length };
  } else if (typeof Object.keys == 'function') {
    keys = Object.keys(object);
  } else {
    keys = [];
    for (var key in object) {
      if (object.hasOwnProperty(key)) keys.push(key);
    }
  }

  // 依路徑取出排序依據的值
  function pick(item) {
    if (Object.prototype.toString.call(subkey) === '[object Array]') {
      var val = item;
      for (var i = 0; i < subkey.length; i++) {
        if (val == null) return undefined;
        val = val[subkey[i]];
      }
      return val;
    }
    if ((subkey === undefined || subkey === null || subkey === '')
         && typeof item.sort === 'function') {
      return item;   // 一維陣列,直接比元素本身
    }
    return subkey ? item[subkey] : item;
  }

  // 氣泡排序:以 keys 為索引,需要時同步搬動物件
  for (var i = 0; i < keys.length; i++) {
    for (var j = i + 1; j < keys.length; j++) {
      var vi = is_array ? pick(object[i]) : pick(object[keys[i]]);
      var vj = is_array ? pick(object[j]) : pick(object[keys[j]]);

      var swap = desc ? (vj > vi) : (vj < vi);
      if (swap) {
        var tmp = keys[i];
        keys[i] = keys[j];
        keys[j] = tmp;
      }
    }
  }

  if (is_array) {
    // 陣列:依排好的索引順序重組
    var sorted = [];
    for (var k = 0; k < keys.length; k++) {
      sorted.push(object[keys[k]]);
    }
    return sorted;
  }

  // 物件:依排好的鍵順序重建
  var result = {};
  for (var m = 0; m < keys.length; m++) {
    result[keys[m]] = object[keys[m]];
  }
  return result;
}

用法一:對物件的子欄位排序

var data = {
  "a": { "session_offline": 10, "session_online": 80,  "session_count": 90 },
  "b": { "session_offline": 20, "session_online": 60,  "session_count": 80 },
  "c": { "session_offline": 30, "session_online": 100, "session_count": 130 },
  "d": { "session_offline": 40, "session_online": 90,  "session_count": 130 }
};

// 依 session_online 升序
data = sort_object(data, 'session_online');
for (var k in data) { console.log(data[k]); }

console.log('------------------');

// 依 session_offline 降序
data = sort_object(data, 'session_offline', true);
for (var k in data) { console.log(data[k]); }

用法二:對物件陣列的欄位排序

var data = [
  { "cpu": 1, "cpuhz": 2.0, "cpuhz_use": 0.5 },
  { "cpu": 2, "cpuhz": 2.5, "cpuhz_use": 0.3 },
  { "cpu": 4, "cpuhz": 3.0, "cpuhz_use": 0.8 },
  { "cpu": 8, "cpuhz": 3.5, "cpuhz_use": 0.6 }
];

data = sort_object(data, 'cpuhz_use');
console.log(data);

用法三:一維陣列

var data = [5, 2, 8, 1, 9, 3, 7, 4];

data = sort_object(data);               // 升序
console.log(data);

data = sort_object(data, null, true);   // 降序
console.log(data);

用法四:純值物件

var data = { 'a': 3, 'b': 1, 'c': 4, 'd': 2 };

data = sort_object(data);              // 依值升序
data = sort_object(data, '', true);    // 依值降序

for (var k in data) { console.log(k, ':', data[k]); }

用法五:多層路徑

var data = {
  "l_": { "l": { "l": 4 } },
  "l_": { "l": { "l": 1 } },
  "l_": { "l": { "l": 3 } },
  "l_": { "l": { "l": 2 } }
};

// 以 ['l', 'l'] 路徑取到的值為排序依據
data = sort_object(data, ['l', 'l']);
for (var k in data) { console.log(data[k].l); }

用法六:陣列中嵌陣列再嵌物件

var data = [
  [ { "a": 1 }, 0, 2 ],
  [ { "a": 3 }, 1, 0 ],
  [ { "a": 2 }, 2, 1 ]
];

// 以每個元素第 0 項的 a 欄位為依據
data = sort_object(data, [0, 'a']);
for (var k = 0; k < data.length; k++) { console.log(data[k]); }

console.log('---------------------');

// 以每個元素第 1 項的值為依據
data = sort_object(data, [1]);
for (var k = 0; k < data.length; k++) { console.log(data[k]); }

現代寫法對照

ES2019 起 Array.prototype.sort 已保證穩定排序,多數場景不必自己實作:

// 物件陣列依欄位排序
data.sort((a, b) => a.cpuhz_use - b.cpuhz_use);

// 降序只要反轉相減方向
data.sort((a, b) => b.cpuhz_use - a.cpuhz_use);

// 多層路徑
data.sort((a, b) => a.l.l - b.l.l);

// 依多個欄位排序(先比第一欄,相同再比第二欄)
data.sort((a, b) => a.type - b.type || a.name.localeCompare(b.name, 'zh-Hant'));

若要對物件的鍵排序,用 Object.entries 配合 sort 再還原:

const sorted = Object.fromEntries(
  Object.entries(data).sort((a, b) => a[1] - b[1])
);

幾個要留意的點

  • 物件並無保證的順序語意。雖然現代引擎會保留插入順序,但純數字鍵會被排到最前面並依數字大小排列,這與 ES 規範的有序性定義有關。若順序是業務需求,應該改用 Map。
  • 比較運算子會做型別轉換。字串 '10' 與數字 9 相比時,'10' > 9 為 true 是因為字串被轉成數字;但兩個字串相比則是逐字元比較字碼。混用型別容易得到意外結果。
  • 氣泡排序是 O(n²)。教學與小資料量沒問題,實務上直接用原生 sort(O(n log n))即可。
XML學習教程| jQuery入門知識| AJAX入門| Dreamweaver教程| Fireworks入門知識| SEO技巧| SEO優化集錦|
Copyright © DIV+CSS佈局教程網 All Rights Reserved