Question

我有这个函数来根据属性对JavaScript对象数组进行排序：

// arr is the array of objects, prop is the property to sort by
var sort = function (prop, arr) {
    arr.sort(function (a, b) {
        if (a[prop] < b[prop]) {
            return -1;
        } else if (a[prop] > b[prop]) {
            return 1;
        } else {
            return 0;
        }
    });
};

它适用于这样的数组：

sort('property', [
    {property:'1'},
    {property:'3'},
    {property:'2'},
    {property:'4'},
]);

但我希望能够通过嵌套属性进行排序，例如：

sort('nestedobj.property', [
    {nestedobj:{property:'1'}},
    {nestedobj:{property:'3'}},
    {nestedobj:{property:'2'}},
    {nestedobj:{property:'4'}}
]);

但是这不起作用，因为无法执行object['nestedobj.property']之类的操作，它应该是object['nestedobj']['property']。

你知道我怎么能解决这个问题并让我的函数使用嵌套对象的属性？

提前致谢

Answer 1

您可以在prop上拆分.，并在每次迭代期间使用下一个嵌套属性迭代更新a和b的数组。

示例： http://jsfiddle.net/x8KD6/1/

var sort = function (prop, arr) {
    prop = prop.split('.');
    var len = prop.length;

    arr.sort(function (a, b) {
        var i = 0;
        while( i < len ) { a = a[prop[i]]; b = b[prop[i]]; i++; }
        if (a < b) {
            return -1;
        } else if (a > b) {
            return 1;
        } else {
            return 0;
        }
    });
    return arr;
};

Answer 2

不是将属性作为字符串传递，而是传递一个可以从顶级对象中检索属性的函数。

var sort = function (propertyRetriever, arr) {
    arr.sort(function (a, b) {
        var valueA = propertyRetriever(a);
        var valueB = propertyRetriever(b);

        if (valueA < valueB) {
            return -1;
        } else if (valueA > valueB) {
            return 1;
        } else {
            return 0;
        }
    });
};

调用as，

var simplePropertyRetriever = function(obj) {
    return obj.property;
};

sort(simplePropertyRetriever, { .. });

或使用嵌套对象

var nestedPropertyRetriever = function(obj) {
    return obj.nestedObj.property;
};

sort(nestedPropertyRetriever, { .. });

Answer 3

使用Array.prototype.sort()和自定义比较功能首先执行降序排序：

champions.sort(function(a, b) { return b.level - a.level }).slice(...

ES6更好：

champions.sort((a, b) => b.level - a.level).slice(...

Answer 4

您可以将Agile.js用于此类事情实际上你传递的是一个表达而不是回调，它以非常好的方式处理嵌套属性和javascript表达式。

用法： _.orderBy(array, expression/callback, reverse[optional])

示例：

var orders = [ { product: { price: 91.12, id: 1 }, date: new Date('01/01/2014') }, { product: { price: 79.21, id: 2 }, date: new Date('01/01/2014') }, { product: { price: 99.90, id: 3 }, date: new Date('01/01/2013') }, { product: { price: 19.99, id: 4 }, date: new Date('01/01/1970') } ]; _.orderBy(orders, 'product.price'); // → [orders[3], orders[1], orders[0], orders[2]] _.orderBy(orders, '-product.price'); // → [orders[2], orders[0], orders[1], orders[3]]

Answer 5

这会满足您的需求吗？

// arr is the array of objects, prop is the property to sort by
var sort = function (nestedObj, prop, arr) {
    arr.sort(function (a, b) {
        if (a[nestedObj][prop] < b[nestedObj][prop]) {
            return -1;
        } else if (a[nestedObj][prop] > b[nestedObj][prop]) {
            return 1;
        } else {
            return 0;
        }
    });
};

Answer 6

试试这个（使用递归函数获取嵌套值，可以将嵌套属性作为nestedobj.property传递）：您可以将此用于任何级别的层次结构

// arr is the array of objects, prop is the property to sort by
var getProperty = function(obj, propNested){
 if(!obj || !propNested){
  return null;
 }
 else if(propNested.length == 1) {
    var key = propNested[0];
    return obj[key];
 }
 else {
  var newObj = propNested.shift();
    return getProperty(obj[newObj], propNested);
 }
};
var sort = function (prop, arr) {
    arr.sort(function (a, b) {
                var aProp = getProperty(a, prop.split("."));
                var bProp = getProperty(a, prop.split("."));
        if (aProp < bProp) {
            return -1;
        } else if (aProp > bProp) {
            return 1;
        } else {
            return 0;
        }
    });
};

Answer 7

这是我的修改代码。

// arr is the array of objects, prop is the property to sort by
var s = function (prop, arr) {
    // add sub function for get value from obj (1/2)
    var _getVal = function(o, key){
        var v = o;
        var k = key.split(".");
        for(var i in k){
            v = v[k[i]];
        }
        return v;
    }
    return arr.sort(function (a, b) {
        // get value from obj a, b before sort (2/2)
        var aVal = _getVal(a, prop);
        var bVal = _getVal(b, prop);
        if (aVal < bVal) {
            return -1;
        } else if (aVal > bVal) {
            return 1;
        } else {
            return 0;
        }
    });
};

Answer 8

如果您有类似对象的数组

const objs = [{
        first_nom: 'Lazslo',
        last_nom: 'Jamf',
        moreDetails: {
            age: 20
        }
    }, {
        first_nom: 'Pig',
        last_nom: 'Bodine',
        moreDetails: {
            age: 21
        }
    }, {
        first_nom: 'Pirate',
        last_nom: 'Prentice',
        moreDetails: {
            age: 22
        }
    }];

您可以简单地使用

nestedSort = (prop1, prop2 = null, direction = 'asc') => (e1, e2) => {
        const a = prop2 ? e1[prop1][prop2] : e1[prop1],
            b = prop2 ? e2[prop1][prop2] : e2[prop1],
            sortOrder = direction === "asc" ? 1 : -1
        return (a < b) ? -sortOrder : (a > b) ? sortOrder : 0;
    }

并调用它

直接对象

objs.sort(nestedSort("last_nom"));
objs.sort(nestedSort("last_nom", null, "desc"));

用于嵌套对象

objs.sort(nestedSort("moreDetails", "age"));
objs.sort(nestedSort("moreDetails", "age", "desc"));

如何通过嵌套对象属性对JavaScript对象数组进行排序？

8 个答案: