我有一个JavaScript对象数组：
var objs = [
{ first_nom: 'Lazslo', last_nom: 'Jamf' },
{ first_nom: 'Pig', last_nom: 'Bodine' },
{ first_nom: 'Pirate', last_nom: 'Prentice' }
];
如何在JavaScript中按last_nom的值对它们进行排序？
我知道排序（a，b），但这似乎只适用于字符串和数字。是否需要向对象添加toString（）方法？
当前回答
您还可以创建一个动态排序函数，根据传递的值对对象进行排序：
function dynamicSort(property) {
var sortOrder = 1;
if(property[0] === "-") {
sortOrder = -1;
property = property.substr(1);
}
return function (a,b) {
/* next line works with strings and numbers,
* and you may want to customize it to your needs
*/
var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
return result * sortOrder;
}
}
所以你可以有一个这样的对象数组：
var People = [
{Name: "Name", Surname: "Surname"},
{Name:"AAA", Surname:"ZZZ"},
{Name: "Name", Surname: "AAA"}
];
…当你这样做时，它会起作用：
People.sort(dynamicSort("Name"));
People.sort(dynamicSort("Surname"));
People.sort(dynamicSort("-Surname"));
事实上，这已经回答了问题。下面的部分是因为许多人联系我，抱怨它不适用于多个参数。
多个参数
您可以使用下面的函数生成具有多个排序参数的排序函数。
function dynamicSortMultiple() {
/*
* save the arguments object as it will be overwritten
* note that arguments object is an array-like object
* consisting of the names of the properties to sort by
*/
var props = arguments;
return function (obj1, obj2) {
var i = 0, result = 0, numberOfProperties = props.length;
/* try getting a different result from 0 (equal)
* as long as we have extra properties to compare
*/
while(result === 0 && i < numberOfProperties) {
result = dynamicSort(props[i])(obj1, obj2);
i++;
}
return result;
}
}
这将使您能够执行以下操作：
People.sort(dynamicSortMultiple("Name", "-Surname"));
子类化数组
对于我们中能够使用ES6的幸运者，ES6允许扩展本机对象：
class MyArray extends Array {
sortBy(...args) {
return this.sort(dynamicSortMultiple(...args));
}
}
这将实现：
MyArray.from(People).sortBy("Name", "-Surname");
其他回答
这里有一个函数，您可以使用它按多个对象对列表进行排序，如果第一个对象相等，则第二个顺序将用作回退。如果可能的话，空值也应忽略到回退顺序。
function sortObjects(list, orderBy){
list.sort(function(a, b){
let byIndex = 0;
let order = orderBy[byIndex];
while(!a[order.by] || !b[order.by] || a[order.by] === b[order.by]){
byIndex++;
if(byIndex >= orderBy.length){break;}
order = orderBy[byIndex];
}
if(!a[order.by] || !b[order.by] || a[order.by] === b[order.by]){
return false;
}
if(order.desc){
return a[order.by] < b[order.by];
}
return a[order.by] > b[order.by];
});
return list;
}
用法：
var objs = [
{a: 10, b: 20, c: 30},
{a: 30, b: 10, c: 20},
{a: 20, b: 10, c: 30},
];
sortObjectList(objs, [{by: 'a'}]);
[
{a: 10, b: 20, c: 30},
{a: 20, b: 10, c: 30},
{a: 30, b: 10, c: 20},
]
sortObjectList(objs, [{by: 'a', desc: true}]);
[
{a: 30, b: 10, c: 20},
{a: 20, b: 10, c: 30},
{a: 10, b: 20, c: 30},
]
sortObjectList(objs, [{by: 'b', desc: true}, {by: 'c'}]);
[
{a: 10, b: 20, c: 30},
{a: 30, b: 10, c: 20},
{a: 20, b: 10, c: 30},
]
另一个例子：
var objs = [
{a: 5, b: 5},
{a: 10, b: 15},
{a: 15, b: 25},
{b: 10},
{b: 20},
{a: 10, b: 30},
{a: 10, b: 12},
];
sortObjectList(objs, [{by: 'a'}, {by: 'b'}]);
[
{a: 5, b: 5},
{b: 10},
{a: 10, b: 12},
{a: 10, b: 15},
{b: 20},
{a: 10, b: 30},
{a: 15, b: 25},
]
这是一个简单的问题。我不知道为什么人们会有如此复杂的解决方案。
一个简单的排序函数（基于快速排序算法）：
function sortObjectsArray(objectsArray, sortKey)
{
// Quick Sort:
var retVal;
if (1 < objectsArray.length)
{
var pivotIndex = Math.floor((objectsArray.length - 1) / 2); // Middle index
var pivotItem = objectsArray[pivotIndex]; // Value in the middle index
var less = [], more = [];
objectsArray.splice(pivotIndex, 1); // Remove the item in the pivot position
objectsArray.forEach(function(value, index, array)
{
value[sortKey] <= pivotItem[sortKey] ? // Compare the 'sortKey' proiperty
less.push(value) :
more.push(value) ;
});
retVal = sortObjectsArray(less, sortKey).concat([pivotItem], sortObjectsArray(more, sortKey));
}
else
{
retVal = objectsArray;
}
return retVal;
}
使用示例：
var myArr =
[
{ val: 'x', idx: 3 },
{ val: 'y', idx: 2 },
{ val: 'z', idx: 5 },
];
myArr = sortObjectsArray(myArr, 'idx');
您还可以创建一个动态排序函数，根据传递的值对对象进行排序：
function dynamicSort(property) {
var sortOrder = 1;
if(property[0] === "-") {
sortOrder = -1;
property = property.substr(1);
}
return function (a,b) {
/* next line works with strings and numbers,
* and you may want to customize it to your needs
*/
var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
return result * sortOrder;
}
}
所以你可以有一个这样的对象数组：
var People = [
{Name: "Name", Surname: "Surname"},
{Name:"AAA", Surname:"ZZZ"},
{Name: "Name", Surname: "AAA"}
];
…当你这样做时，它会起作用：
People.sort(dynamicSort("Name"));
People.sort(dynamicSort("Surname"));
People.sort(dynamicSort("-Surname"));
事实上，这已经回答了问题。下面的部分是因为许多人联系我，抱怨它不适用于多个参数。
多个参数
您可以使用下面的函数生成具有多个排序参数的排序函数。
function dynamicSortMultiple() {
/*
* save the arguments object as it will be overwritten
* note that arguments object is an array-like object
* consisting of the names of the properties to sort by
*/
var props = arguments;
return function (obj1, obj2) {
var i = 0, result = 0, numberOfProperties = props.length;
/* try getting a different result from 0 (equal)
* as long as we have extra properties to compare
*/
while(result === 0 && i < numberOfProperties) {
result = dynamicSort(props[i])(obj1, obj2);
i++;
}
return result;
}
}
这将使您能够执行以下操作：
People.sort(dynamicSortMultiple("Name", "-Surname"));
子类化数组
对于我们中能够使用ES6的幸运者，ES6允许扩展本机对象：
class MyArray extends Array {
sortBy(...args) {
return this.sort(dynamicSortMultiple(...args));
}
}
这将实现：
MyArray.from(People).sortBy("Name", "-Surname");
排序（更多）复杂的对象阵列
由于您可能会遇到类似于此阵列的更复杂的数据结构，因此我将扩展解决方案。
TL；博士
是基于@ege-Özcan非常可爱的答案的更可插拔版本。
问题
我遇到了下面的问题，无法更改它。我也不想暂时压平对象。我也不想使用下划线/lodash，主要是出于性能原因和自己实现它的乐趣。
var People = [
{Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
{Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
{Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];
Goal
目标是主要按People.Name.Name排序，其次按People.Name.surname排序
障碍
现在，在基本解决方案中，使用括号表示法来计算要动态排序的财产。不过，在这里，我们还必须动态地构造括号表示法，因为您可能会期望像People['Name.Name']这样的符号会起作用，但这不起作用。
另一方面，简单地做人物['Name']['Name']是静态的，只允许你进入第n层。
解决方案
这里的主要添加是遍历对象树并确定最后一个叶以及任何中间叶的值。
var People = [
{Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
{Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
{Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];
People.sort(dynamicMultiSort(['Name','name'], ['Name', '-surname']));
// Results in...
// [ { Name: { name: 'AAA', surname: 'ZZZ' }, Middlename: 'Abrams' },
// { Name: { name: 'Name', surname: 'Surname' }, Middlename: 'JJ' },
// { Name: { name: 'Name', surname: 'AAA' }, Middlename: 'Wars' } ]
// same logic as above, but strong deviation for dynamic properties
function dynamicSort(properties) {
var sortOrder = 1;
// determine sort order by checking sign of last element of array
if(properties[properties.length - 1][0] === "-") {
sortOrder = -1;
// Chop off sign
properties[properties.length - 1] = properties[properties.length - 1].substr(1);
}
return function (a,b) {
propertyOfA = recurseObjProp(a, properties)
propertyOfB = recurseObjProp(b, properties)
var result = (propertyOfA < propertyOfB) ? -1 : (propertyOfA > propertyOfB) ? 1 : 0;
return result * sortOrder;
};
}
/**
* Takes an object and recurses down the tree to a target leaf and returns it value
* @param {Object} root - Object to be traversed.
* @param {Array} leafs - Array of downwards traversal. To access the value: {parent:{ child: 'value'}} -> ['parent','child']
* @param {Number} index - Must not be set, since it is implicit.
* @return {String|Number} The property, which is to be compared by sort.
*/
function recurseObjProp(root, leafs, index) {
index ? index : index = 0
var upper = root
// walk down one level
lower = upper[leafs[index]]
// Check if last leaf has been hit by having gone one step too far.
// If so, return result from last step.
if (!lower) {
return upper
}
// Else: recurse!
index++
// HINT: Bug was here, for not explicitly returning function
// https://stackoverflow.com/a/17528613/3580261
return recurseObjProp(lower, leafs, index)
}
/**
* Multi-sort your array by a set of properties
* @param {...Array} Arrays to access values in the form of: {parent:{ child: 'value'}} -> ['parent','child']
* @return {Number} Number - number for sort algorithm
*/
function dynamicMultiSort() {
var args = Array.prototype.slice.call(arguments); // slight deviation to base
return function (a, b) {
var i = 0, result = 0, numberOfProperties = args.length;
// REVIEW: slightly verbose; maybe no way around because of `.sort`-'s nature
// Consider: `.forEach()`
while(result === 0 && i < numberOfProperties) {
result = dynamicSort(args[i])(a, b);
i++;
}
return result;
}
}
实例
JSBin的工作示例
您可以使用最简单的方式：Lodash
(https://lodash.com/docs/4.17.10#orderBy)
此方法类似于_.sortBy，只是它允许指定要排序的迭代项的排序顺序。如果未指定顺序，则所有值都按升序排序。否则，为相应值的降序指定“desc”，为升序指定“asc”。
论据
collection（Array | Object）：要迭代的集合。[iteratees=[_.identity]]（数组[]|函数[]|对象[]|字符串[]）：要排序的iterates。[orders]（string[]）：迭代的排序顺序。
退换商品
（Array）：返回新的排序数组。
var _ = require('lodash');
var homes = [
{"h_id":"3",
"city":"Dallas",
"state":"TX",
"zip":"75201",
"price":"162500"},
{"h_id":"4",
"city":"Bevery Hills",
"state":"CA",
"zip":"90210",
"price":"319250"},
{"h_id":"6",
"city":"Dallas",
"state":"TX",
"zip":"75000",
"price":"556699"},
{"h_id":"5",
"city":"New York",
"state":"NY",
"zip":"00010",
"price":"962500"}
];
_.orderBy(homes, ['city', 'state', 'zip'], ['asc', 'desc', 'asc']);
