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