Javascript 排序数组或对象

分享一个用于数组或者对象的排序的函数。该函数可以以任意深度的数组或者对象的值作为排序基数对数组或的元素进行排序。

代码如下：

 

/**
 * 排序数组或者对象
 * by Jinko
 * date 2015-12-23
 * @param object 数组或对象
 * @param subkey 需要排序的子键, 该参数可以是字符串, 也可以是一个数组
 * @param desc 排序方式, true:降序, false|undefined:升序
 * @returns {*} 返回排序后的数组或者对象
 *
 * 注意: 对于对象的排序, 如果使用console.log打印对象的显示可能和排序结果不一致,
 *    其键会被浏览器以字母顺序排序显示,但在for循环中则为正确的排序顺序
 */
function sort_object(object, subkey, desc)
{
    var is_array = false;

    if(Object.prototype.toString.call(object) === '[object Array]') {
        is_array = true;
    }

    if(is_array) {
        var keys = {length:object.length};
    } else {
        if(typeof(Object.keys) == 'function') {
            var keys = Object.keys(object);
        } else{
            var keys = [];
            for(var key in keys) {
                keys.push(key);
            }
        }
    }

    for(var i=0; i<keys.length; i++) {
        for(var j=i+1; j<keys.length; j++) {

            if(is_array) {
                //数组排序
                if(Object.prototype.toString.call(subkey) === '[object Array]') {
                    var vali = object[i];
                    var valj = object[j];

                    for(var si=0; si<subkey.length; si++) {
                        vali = vali[ subkey[si] ];
                        valj = valj[ subkey[si] ];
                    }
                } else {
                    if((!subkey && subkey !== 0) || subkey == '' && object.sort) {
                        var vali = object[i];
                        var valj = object[j];
                    } else {
                        var vali = object[i][subkey];
                        var valj = object[j][subkey];
                    }
                }

                if(desc) {
                    if(valj > vali) {
                        var tmp = object[i];
                        object[i] = object[j];
                        object[j] = tmp;
                    }
                } else {
                    if(valj < vali) {
                        var tmp = object[i];
                        object[i] = object[j];
                        object[j] = tmp;
                    }
                }
            } else {
                //对象排序
                var obi = object[ keys[i] ];
                var obj = object[ keys[j] ];

                if(Object.prototype.toString.call(subkey) === '[object Array]') {
                    var vali = obi;
                    var valj = obj;

                    for(var si=0; si<subkey.length; si++) {
                        vali = vali[ subkey[si] ];
                        valj = valj[ subkey[si] ];
                    }
                } else {
                    if((!subkey && subkey !== 0) || subkey == '' && object.sort) {
                        var vali = obi;
                        var valj = obj;
                    } else {
                        var vali = obi[subkey];
                        var valj = obj[subkey];
                    }
                }

                if(desc) {
                    if(valj > vali) {
                        var tmp = keys[i];
                        keys[i] = keys[j];
                        keys[j] = tmp;
                    }
                } else {
                    if(valj < vali) {
                        var tmp = keys[i];
                        keys[i] = keys[j];
                        keys[j] = tmp;
                    }
                }
            }//is!array
        }
    }

    if(is_array) {
        return object;
    } else {
        var sorted = {};

        for(var i=0; i<keys.length; i++) {
            sorted[ keys[i] ] = object[ keys[i] ];
        }

        return sorted;
    }
} //sort_object

 

 

 

用法如下：

 

用法1: 

var data = {
    "a": {
        "session_offline": 21,
        "session_online": 6,
        "session_count": 1
    },
    "b": {
        "session_offline": 15,
        "session_online": 5,
        "session_count": 1
    },
    "c": {
        "session_offline": 6,
        "session_online": 1,
        "session_count": 1
    },
    "d": {
        "session_offline": 2,
        "session_online": 0,
        "session_count": 1
    }
};

//根据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]);
}

 

 

用法2:

var data2 = [
    {
        "cpu": 24,
        "cpuhz": 2099,
        "cpuhz_use": 1322,
    },
    {
        "cpu": 24,
        "cpuhz": 2099,
        "cpuhz_use": 694,
    },
    {
        "cpu": 24,
        "cpuhz": 2099,
        "cpuhz_use": 1622,
    },
    {
        "cpu": 24,
        "cpuhz": 2099,
        "cpuhz_use": 322,
    }
];

//根据cpuhz_use字段进行排序
data2 = sort_object(data2, 'cpuhz_use');

console.log(data2);

 

 

用法3:

var data3 = [1,3,2,5,9,7,3,7];

//对一维数组进行升序排序
data3 = sort_object(data3);
console.log(data3);

//对一维数组进行降序排序
data3 = sort_object(data3, null, true);
console.log(data3);

 

 

用法4:

var data4 = {'a':45, 'b':36, 'c':11, 'd':32};

//对对象进行升序排序
data4 = sort_object(data4);
//对对象进行降序排序
data4 = sort_object(data4, '', true);

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

 用法5:

var data5 = {
    "l1_1": {
        "l2": {
            "l3": 1
        }
    },
    "l1_2": {
        "l2": {
            "l3": 3
        }
    },
    "l1_3": {
        "l2": {
            "l3": 2
        }
    },
    "l1_4": {
        "l2": {
            "l3": 4
        }
    }
};

//对对象元素的l2下的l3的值为基础进行升序排序
data5 = sort_object(data5, ['l2', 'l3']);

for(var k in data5) {
    console.log(data5[k].l2);
}

 

 

用法6:

var data6 = [
    [
        {
            "a": 1
        },
        2,
        3
    ],
    [
        {
            "a": 6
        },
        4,
        7
    ],
    [
        {
            "a": 0
        },
        1,
        6
    ]
];

//对数组的元素以下标为0的元素的键名为a的值为基础进行升序排序
data6 = sort_object(data6, [0,'a']);

for(var k = 0; k<data6.length; k++) {
    console.log(data6[k]);
}

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

//对数组的元素以下标为2的元素的值为基础进行升序排序
data6 = sort_object(data6, [2]); // 等价于 data6 = sort_object(data6, 2);

for(var k = 0; k<data6.length; k++) {
    console.log(data6[k]);
}