Js实现Object按照值的某些字段（数值类型）的大小进行排序

最近，有个需求：将一个Object对象，按照值的某些字段（数值型）的大小来进行排序。感觉这个需求也算是有点用，也有点意思吧！就记录分享一下。

看代码，写的很挫，将就着看吧。能用就行，哈哈！

var objs = {
    "aaa": { name: "小明", age: 30, gn: 7 },
    "bbb": { name: "小红", age: 20, gn: 8 },
    "ccc": { name: "小花", age: 40, gn: 3 }
}

/**
 * 
 * @param {*} obj Object对象
 * @param {*} propertys 值中的属性列表（数组）
 * @param {*} desc 是否是降序 （升序：从小到大；降序：从大到小）
 */
function ObjSort(obj, propertys, desc) {

    let same = function (obj1, obj2) {
        var o1 = obj1 instanceof Object;
        var o2 = obj2 instanceof Object;
        if (!o1 || !o2) {/*  判断不是对象  */
            return obj1 === obj2;
        }

        if (Object.keys(obj1).length !== Object.keys(obj2).length) {
            return false;
        }

        for (var attr in obj1) {
            var t1 = obj1[attr] instanceof Object;
            var t2 = obj2[attr] instanceof Object;
            if (t1 && t2) {
                return same(obj1[attr], obj2[attr]);
            } else if (obj1[attr] !== obj2[attr]) {
                return false;
            }
        }
        return true;
    }

    var arr = [];
    for (var key in obj) {
        arr.push(obj[key]);
    }

    arr.sort((a, b) => {
        let valuesA = [];
        let valuesB = [];
        for (let i = 0; i < propertys.length; i++) {
            valuesA.push(a[propertys[i]]);
            valuesB.push(b[propertys[i]]);
        }

        let sumA = 0;
        let sumB = 0;

        valuesA.forEach(item => {
            sumA += item;
        });

        valuesB.forEach(item => {
            sumB += item;
        })

        if (desc == true) {
            // 降序排列  从大到小
            return sumB - sumA;
        } else {
            // 升序排列  从小到大
            return sumA - sumB;
        }
    });

    let oldObj = obj;

    let obj2 = {};
    let maxIdx = 0;//最大值 的 index
    let minIdx = 0;//最小值 的 index

    if (desc) {//小到大
        maxIdx = arr.length - 1;
        minIdx = 0;
        while (maxIdx > minIdx) {
            for (let key in oldObj) {
                if (same(oldObj[key], arr[minIdx])) {
                    let str = JSON.stringify(arr[minIdx]);
                    obj2[str] = key;
                    if (maxIdx > minIdx) {
                        minIdx++;
                    }
                }
            }
        }
    } else {//大到小
        maxIdx = 0;
        minIdx = arr.length - 1;
        while (maxIdx < minIdx) {
            for (let key in oldObj) {
                console.log(oldObj[key]);
                console.log(arr[maxIdx]);
                if (same(oldObj[key], arr[maxIdx])) {
                    let str = JSON.stringify(arr[maxIdx]);
                    obj2[str] = key;
                    if (maxIdx < minIdx) {
                        maxIdx++;
                    }
                }
            }
        }
    }

    let newObj = {};
    for (let key in obj2) {
        newObj[obj2[key]] = JSON.parse(key);
    }

    return newObj;
}

let newObjs = ObjSort(objs, ["gn", "age"], true);

console.log(newObjs);

可以看到，传入的propertys是一个数组，有gn、age两个属性。那么值的排序依据就是这个属性数组对应的值之和。

运行截图：

最后特别注意：
当对象的key（键）为数字时，Object会自动排序。，本次栗子不适用于key为数字的场景。