200

假设您有一个这样的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"]

但是如何使它与对象列表一起使用？

javascript

— 戴维斯
source

您可以将sort函数作为.sort（）的第一个参数传递。

— Paul Tomblin，2012年

2

由于您使用的DepartmentFactory是构造函数，因此请使用创建其对象new DepartmentFactory，否则该数组将填充一堆undefined值。

— 阿努拉格2012年

341

您将必须执行以下操作：

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

注意：更改大小写（大写或小写）可确保不区分大小写。

— 欧默·波卡里（Omer Bokhari）
source

3

我已经为您解答了50万亿亿遍，因为我不记得该怎么做。FWIW，我的Linter总是告诉我“表达式周围有多余的括号”：不愿return (textA < textB) ? -1 : (textA > textB) ? 1 : 0;编辑您的答案，并希望我至少记得

— 起毛的

感谢这个Omer

— Ted Fitzpatrick

找到了与此代码有关的问题。使用小写和大写字母的组合。例如 credit_card_no和城市。代码不会对列表进行排序，但是以'c'开头的单词不会分组在一起。

— Kedar

156

要支持unicode：

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

— 罗恩·托南贝
source

7

对于不区分大小写的版本，请在第2行上使用以下代码：return a.DepartmentName.toLowerCase().localeCompare(b.DepartmentName.toLowerCase());

— Ben Barreth

3

每天学习新东西- localeCompare很酷，并且对第一个参数具有所有浏览器支持。不错！

— obzenner

4

@BenBarreth没有理由将字符串小写。整个过程的重点localeCompare是将管理排序逻辑和语言环境怪异的工作分流到系统中。如果对语言环境而言不区分大小写排序是正常的（如英语一样），则将为您完成此操作： "Z" > 'a' // false "Z".localeCompare('a') // 1 如果希望偏离语言环境的默认值，则可以在locales和options参数中发送重写：developer.mozilla。 org / zh-CN / docs / Web / JavaScript / Reference /…

— Jon z

12

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/

— 二极管
source

9

// 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
*/

— 鲍勃
source

5

演示

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}));

— qwertymk
source

2

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

— 尼尔
source

1

像这样做

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)

— 尼克莉弗莉
source

1

objArray.sort( (a, b) => a.id.localeCompare(b.id, 'en', {'sensitivity': 'base'}));

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

— 艾丽莎
source

比公认的解决方案优雅得多！

— 卡诺

0

这是一个简单的函数，可用于通过对象的属性对对象数组进行排序；该属性是字符串类型还是整数类型都无所谓，它将起作用。

    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);

展开摘要

— 迈克尔·诺沃德
source

-1

您必须传递一个接受两个参数，比较它们并返回数字的函数，因此假设您想按ID对它们进行排序，您将编写...

objArray.sort(function(a,b) {
    return a.id-b.id;
});
// objArray is now sorted by Id

— zconnelly13
source

5

他问有关按DepartmentName（而不是ID）排序的问题。

— Paul Tomblin 2012年

我试过了，这似乎不适用于字符串列...它适用于日期列。起作用的是@ omer-bokhari的解决方案

— tsando

-2

在尝试了这一点并尝试使循环尽可能少之后，我最终得到了以下解决方案：

Codepen上的演示

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);

— Alexandre Magno Teles Zimerer
source

-3

一个简单的答案：

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;
});

— 玛莎
source

在数组的一个属性上按字母顺序对数组中的对象进行排序

演示