根据数组的一个属性按字母顺序对数组中的对象排序

假设你有一个这样的JavaScript类

var DepartmentFactory = function(data) {
this.id = data.Id;
this.name = data.DepartmentName;
this.active = data.Active;
}

假设您随后创建了该类的许多实例，并将它们存储在一个数组中

var objArray = [];
objArray.push(DepartmentFactory({Id: 1, DepartmentName: 'Marketing', Active: true}));
objArray.push(DepartmentFactory({Id: 2, DepartmentName: 'Sales', Active: true}));
objArray.push(DepartmentFactory({Id: 3, DepartmentName: 'Development', Active: true}));
objArray.push(DepartmentFactory({Id: 4, DepartmentName: 'Accounting', Active: true}));

所以我现在有了一个由DepartmentFactory创建的对象数组。如何使用array.sort()方法根据每个对象的DepartmentName属性对这个对象数组进行排序?

array.sort()方法在对字符串数组排序时工作得很好

var myarray=["Bob", "Bully", "Amy"];
myarray.sort(); //Array now becomes ["Amy", "Bob", "Bully"]

但是我如何让它与对象列表一起工作呢?

298940 次浏览
小开

你必须传递一个接受两个参数的函数，比较它们，并返回一个数字，所以假设你想要根据ID对它们排序，你会写…

objArray.sort(function(a,b) {
return a.id-b.id;
});
// objArray is now sorted by Id
小开
最佳答案

你必须这样做:

objArray.sort(function(a, b) {
var textA = a.DepartmentName.toUpperCase();
var textB = b.DepartmentName.toUpperCase();
return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;
});

注意:改变大小写(改为大写或小写)可以确保不区分大小写。

小开

要支持unicode:

objArray.sort(function(a, b) {
return a.DepartmentName.localeCompare(b.DepartmentName);
});
小开

DEMO

var DepartmentFactory = function(data) {
this.id = data.Id;
this.name = data.DepartmentName;
this.active = data.Active;
}


var objArray = [];
objArray.push(new DepartmentFactory({Id: 1, DepartmentName: 'Marketing', Active: true}));
objArray.push(new DepartmentFactory({Id: 2, DepartmentName: 'Sales', Active: true}));
objArray.push(new DepartmentFactory({Id: 3, DepartmentName: 'Development', Active: true}));
objArray.push(new DepartmentFactory({Id: 4, DepartmentName: 'Accounting', Active: true}));


console.log(objArray.sort(function(a, b) { return a.name > b.name}));
小开 
var DepartmentFactory = function(data) {
this.id = data.Id;
this.name = data.DepartmentName;
this.active = data.Active;
}


// use `new DepartmentFactory` as given below. `new` is imporatant


var objArray = [];
objArray.push(new DepartmentFactory({Id: 1, DepartmentName: 'Marketing', Active: true}));
objArray.push(new DepartmentFactory({Id: 2, DepartmentName: 'Sales', Active: true}));
objArray.push(new DepartmentFactory({Id: 3, DepartmentName: 'Development', Active: true}));
objArray.push(new DepartmentFactory({Id: 4, DepartmentName: 'Accounting', Active: true}));


function sortOn(property){
return function(a, b){
if(a[property] < b[property]){
return -1;
}else if(a[property] > b[property]){
return 1;
}else{
return 0;
}
}
}


//objArray.sort(sortOn("id")); // because `this.id = data.Id;`
objArray.sort(sortOn("name")); // because `this.name = data.DepartmentName;`
console.log(objArray);

演示:http://jsfiddle.net/diode/hdgeH/

小开

像这样做

objArrayy.sort(function(a, b){
var nameA=a.name.toLowerCase(), nameB=b.name.toLowerCase()
if (nameA < nameB) //sort string ascending
return -1
if (nameA > nameB)
return 1
return 0 //default return value (no sorting)
});
console.log(objArray)
小开 
// Sorts an array of objects "in place". (Meaning that the original array will be modified and nothing gets returned.)
function sortOn (arr, prop) {
arr.sort (
function (a, b) {
if (a[prop] < b[prop]){
return -1;
} else if (a[prop] > b[prop]){
return 1;
} else {
return 0;
}
}
);
}


//Usage example:


var cars = [
{make:"AMC",        model:"Pacer",  year:1978},
{make:"Koenigsegg", model:"CCGT",   year:2011},
{make:"Pagani",     model:"Zonda",  year:2006},
];


// ------- make -------
sortOn(cars, "make");
console.log(cars);


/* OUTPUT:
AMC         : Pacer : 1978
Koenigsegg  : CCGT  : 2011
Pagani      : Zonda : 2006
*/






// ------- model -------
sortOn(cars, "model");
console.log(cars);


/* OUTPUT:
Koenigsegg  : CCGT  : 2011
AMC         : Pacer : 1978
Pagani      : Zonda : 2006
*/






// ------- year -------
sortOn(cars, "year");
console.log(cars);


/* OUTPUT:
AMC         : Pacer : 1978
Pagani      : Zonda : 2006
Koenigsegg  : CCGT  : 2011
*/
小开

一个简单的答案:

objArray.sort(function(obj1, obj2) {
return obj1.DepartmentName > obj2.DepartmentName;
});

ES6道:

objArray.sort((obj1, obj2) => {return obj1.DepartmentName > obj2.DepartmentName};

如果你需要让它小写或大写等，只要这样做，并将结果存储在一个变量中，而不是比较该变量。例子:

objArray.sort((obj1, obj2) => {
var firstObj = obj1.toLowerCase();
var secondObj = obj2.toLowerCase();
return firstObj.DepartmentName > secondObj.DepartmentName;
});
小开

在这个问题上做了一些尝试，并尽量减少循环之后，我最终得到了这个解决方案:

< a href = " https://codepen.io/alexanmtz/pen/KBYXMY?编辑=0012" rel="nofollow noreferrer">代码依赖的演示

const items = [
{
name: 'One'
},
{
name: 'Maria is here'
},
{
name: 'Another'
},
{
name: 'Z with a z'
},
{
name: '1 number'
},
{
name: 'Two not a number'
},
{
name: 'Third'
},
{
name: 'Giant'
}
];


const sorted = items.sort((a, b) => {
return a[name] > b[name];
});


let sortedAlphabetically = {};


for(var item in sorted) {
const firstLetter = sorted[item].name[0];
if(sortedAlphabetically[firstLetter]) {
sortedAlphabetically[firstLetter].push(sorted[item]);
} else {
sortedAlphabetically[firstLetter] = [sorted[item]];
}
}


console.log('sorted', sortedAlphabetically);
小开 
objArray.sort( (a, b) => a.id.localeCompare(b.id, 'en', {'sensitivity': 'base'}));

这将按字母顺序对它们进行排序，并且不区分大小写。它也非常干净，易于阅读:D

小开 
objArray.sort((a, b) => a.DepartmentName.localeCompare(b.DepartmentName))
小开

这是一个简单的函数，你可以用它来排序数组对象的属性;不管属性是字符串类型还是整数类型，它都可以工作。

    var cars = [
{make:"AMC",        model:"Pacer",  year:1978},
{make:"Koenigsegg", model:"CCGT",   year:2011},
{make:"Pagani",     model:"Zonda",  year:2006},
];


function sortObjectsByProp(objectsArr, prop, ascending = true) {
let objectsHaveProp = objectsArr.every(object => object.hasOwnProperty(prop));
if(objectsHaveProp)    {
let newObjectsArr = objectsArr.slice();
newObjectsArr.sort((a, b) => {
if(isNaN(Number(a[prop])))  {
let textA = a[prop].toUpperCase(),
textB = b[prop].toUpperCase();
if(ascending)   {
return textA < textB ? -1 : textA > textB ? 1 : 0;
} else {
return textB < textA ? -1 : textB > textA ? 1 : 0;
}
} else {
return ascending ? a[prop] - b[prop] : b[prop] - a[prop];
}
});
return newObjectsArr;
}
return objectsArr;
}


let sortedByMake = sortObjectsByProp(cars, "make"); // returns ascending order by its make;
let sortedByYear = sortObjectsByProp(cars, "year", false); // returns descending order by its year,since we put false as a third argument;
console.log(sortedByMake);
console.log(sortedByYear);

小开

ES6代码更短

objArray.sort((a, b) => a.DepartmentName.toLowerCase().localeCompare(b.DepartmentName.toLowerCase()))
小开

因为这里给出的所有解决方案都没有null/undefined安全操作，所以我用这种方式处理(你可以根据自己的需要处理null):

ES5

objArray.sort(
function(a, b) {
var departmentNameA = a.DepartmentName ? a.DepartmentName : '';
var departmentNameB = b.DepartmentName ? b.DepartmentName : '';


departmentNameA.localeCompare(departmentNameB);
}
);

ES6 +

objArray.sort(
(a: DepartmentFactory, b: DepartmentFactory): number => {
const departmentNameA = a.DepartmentName ? a.DepartmentName : '';
const departmentNameB = b.DepartmentName ? b.DepartmentName : '';


departmentNameA.localeCompare(departmentNameB);
}
);

我还删除了其他人使用的toLowerCase，因为localeCompare是不区分大小写的。另外，在使用Typescript或ES6+时，我更喜欢在参数上更明确一点，以便对未来的开发人员更明确。


提交答案