如何按多个字段排序对象数组?

改编自@chriskelly的回答。

大多数答案都忽略了，如果价值在1万美元以下或超过100万美元，价格将无法正确排序。原因是JS按字母顺序排序。这里回答得很好，为什么JavaScript不能对“5,10,1”排序，这里如何正确地对整数数组排序。

最后，如果我们要排序的字段或节点是一个数字，我们必须做一些计算。我并不是说在这种情况下使用parseInt()是正确的答案，排序结果更重要。

用来测试的小提琴

2017-11-28 16:28:17

下面的函数将允许您对一个或多个属性上的对象数组进行排序，对每个属性进行升序(默认值)或降序排序，并允许您选择是否执行区分大小写的比较。默认情况下，该函数执行不区分大小写的排序。

第一个参数必须是包含对象的数组。后面的参数必须是一个以逗号分隔的字符串列表，这些字符串引用要排序的不同对象属性。最后一个参数(可选)是一个布尔值，用于选择是否执行区分大小写的排序——区分大小写的排序使用true。

默认情况下，该函数将按升序对每个属性/键排序。如果你想要一个特定的键按降序排序，那么取而代之的是传递一个这样格式的数组:['property_name'， true]。

下面是该函数的一些示例用法，后面附有解释(其中homes是一个包含对象的数组):

objSort(homes， 'city')—>按城市排序(升序，不区分大小写)

objSort(homes， ['city'， true])——>按城市排序(降序，不区分大小写)

objSort(homes， 'city'， true)—>按城市然后价格排序(升序，区分大小写)

objSort(homes， 'city'， 'price')——>先按城市再按价格排序(均为升序，不区分大小写)

objSort(homes， 'city'， ['price'， true])——>排序城市(升序)然后价格(降序)，不区分大小写)

话不多说，下面是函数:

function objSort() {
    var args = arguments,
        array = args[0],
        case_sensitive, keys_length, key, desc, a, b, i;

    if (typeof arguments[arguments.length - 1] === 'boolean') {
        case_sensitive = arguments[arguments.length - 1];
        keys_length = arguments.length - 1;
    } else {
        case_sensitive = false;
        keys_length = arguments.length;
    }

    return array.sort(function (obj1, obj2) {
        for (i = 1; i < keys_length; i++) {
            key = args[i];
            if (typeof key !== 'string') {
                desc = key[1];
                key = key[0];
                a = obj1[args[i][0]];
                b = obj2[args[i][0]];
            } else {
                desc = false;
                a = obj1[args[i]];
                b = obj2[args[i]];
            }

            if (case_sensitive === false && typeof a === 'string') {
                a = a.toLowerCase();
                b = b.toLowerCase();
            }

            if (! desc) {
                if (a < b) return -1;
                if (a > b) return 1;
            } else {
                if (a > b) return -1;
                if (a < b) return 1;
            }
        }
        return 0;
    });
} //end of objSort() function

下面是一些样本数据:

var homes = [{
    "h_id": "3",
    "city": "Dallas",
    "state": "TX",
    "zip": "75201",
    "price": 162500
}, {
    "h_id": "4",
    "city": "Bevery Hills",
    "state": "CA",
    "zip": "90210",
    "price": 1000000
}, {
    "h_id": "5",
    "city": "new york",
    "state": "NY",
    "zip": "00010",
    "price": 1000000
}, {
    "h_id": "6",
    "city": "Dallas",
    "state": "TX",
    "zip": "85000",
    "price": 300000
}, {
    "h_id": "7",
    "city": "New York",
    "state": "NY",
    "zip": "00020",
    "price": 345000
}];

2013-06-23 20:43:24

改编自@chriskelly的回答。

大多数答案都忽略了，如果价值在1万美元以下或超过100万美元，价格将无法正确排序。原因是JS按字母顺序排序。这里回答得很好，为什么JavaScript不能对“5,10,1”排序，这里如何正确地对整数数组排序。

最后，如果我们要排序的字段或节点是一个数字，我们必须做一些计算。我并不是说在这种情况下使用parseInt()是正确的答案，排序结果更重要。

用来测试的小提琴

2017-11-28 16:28:17

这是另一个可能更接近您对语法的想法的例子

function sortObjects(objArray, properties /*, primers*/) {
    var primers = arguments[2] || {}; // primers are optional

    properties = properties.map(function(prop) {
        if( !(prop instanceof Array) ) {
            prop = [prop, 'asc']
        }
        if( prop[1].toLowerCase() == 'desc' ) {
            prop[1] = -1;
        } else {
            prop[1] = 1;
        }
        return prop;
    });

    function valueCmp(x, y) {
        return x > y ? 1 : x < y ? -1 : 0; 
    }

    function arrayCmp(a, b) {
        var arr1 = [], arr2 = [];
        properties.forEach(function(prop) {
            var aValue = a[prop[0]],
                bValue = b[prop[0]];
            if( typeof primers[prop[0]] != 'undefined' ) {
                aValue = primers[prop[0]](aValue);
                bValue = primers[prop[0]](bValue);
            }
            arr1.push( prop[1] * valueCmp(aValue, bValue) );
            arr2.push( prop[1] * valueCmp(bValue, aValue) );
        });
        return arr1 < arr2 ? -1 : 1;
    }

    objArray.sort(function(a, b) {
        return arrayCmp(a, b);
    });
}

// just for fun use this to reverse the city name when sorting
function demoPrimer(str) {
    return str.split('').reverse().join('');
}

// Example
sortObjects(homes, ['city', ['price', 'desc']], {city: demoPrimer});

演示:http://jsfiddle.net/Nq4dk/2/

编辑:只是为了好玩，这里有一个变化，只需要一个类似sql的字符串，所以你可以做sortObjects(房屋，“城市，价格desc”)

function sortObjects(objArray, properties /*, primers*/) {
    var primers = arguments[2] || {};

    properties = properties.split(/\s*,\s*/).map(function(prop) {
        prop = prop.match(/^([^\s]+)(\s*desc)?/i);
        if( prop[2] && prop[2].toLowerCase() === 'desc' ) {
            return [prop[1] , -1];
        } else {
            return [prop[1] , 1];
        }
    });

    function valueCmp(x, y) {
        return x > y ? 1 : x < y ? -1 : 0; 
    }

    function arrayCmp(a, b) {
        var arr1 = [], arr2 = [];
        properties.forEach(function(prop) {
            var aValue = a[prop[0]],
                bValue = b[prop[0]];
            if( typeof primers[prop[0]] != 'undefined' ) {
                aValue = primers[prop[0]](aValue);
                bValue = primers[prop[0]](bValue);
            }
            arr1.push( prop[1] * valueCmp(aValue, bValue) );
            arr2.push( prop[1] * valueCmp(bValue, aValue) );
        });
        return arr1 < arr2 ? -1 : 1;
    }

    objArray.sort(function(a, b) {
        return arrayCmp(a, b);
    });
}

2011-08-02 14:58:26

我一直在寻找类似的东西，最后得到了这个:

首先，我们有一个或多个排序函数，总是返回0、1或-1:

const sortByTitle = (a, b): number => 
  a.title === b.title ? 0 : a.title > b.title ? 1 : -1;

您可以为想要排序的其他属性创建更多函数。

然后我有一个函数将这些排序函数合并为一个:

const createSorter = (...sorters) => (a, b) =>
  sorters.reduce(
    (d, fn) => (d === 0 ? fn(a, b) : d),
    0
  );

这可以用来以一种可读的方式组合上述排序函数:

const sorter = createSorter(sortByTitle, sortByYear)

items.sort(sorter)

当一个排序函数返回0时，将调用下一个排序函数进行进一步排序。

2019-05-05 08:08:52

您可以使用链式排序方法，取值的增量，直到它达到不等于零的值。

或者，使用es6，简单地:

data.sort((a, b) => a.city.localeCompare(b.city) || b.price - a.price);

2017-09-16 16:43:31

如何按多个字段排序对象数组?

推荐文章

最新文章

标签