就像这样:

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

假设您有一个用户数组。你可以使用用户。排序并传递一个函数，该函数接受两个参数并进行比较(comparator)

它应该会返回

如果第一个参数小于第二个参数，则为负数(在结果数组中应放在第二个参数之前) 如果第一个参数更大，则为正(应放在第二个参数之后) 如果这两个元素相等，则为0。

在我们的例子中，如果两个元素是a和b，我们想比较a.firstname和b.firstname

例子:

users.sort(function(a, b){
    if(a.firstname < b.firstname) { return -1; }
    if(a.firstname > b.firstname) { return 1; }
    return 0;
})

这段代码适用于任何类型。

请注意，在“现实生活”™中，当您比较字符串时，您经常希望忽略大小写，正确排序变音符，像ß这样奇怪的符号，等等，因此您可能需要使用localeCompare。请看其他答案。

基本上你可以用sort方法对数组排序，但如果你想对对象排序，你就必须传递function给数组的sort方法，我会给你一个使用数组的例子

user = [
  {
    bio: "<null>",
    email: "user@domain.example",
    firstname: "Anna",
    id: 318,
    last_avatar: "<null>",
    last_message: "<null>",
    lastname: "Nickson",
    nickname: "anny",
  },
  {
    bio: "<null>",
    email: "user@domain.example",
    firstname: "Senad",
    id: 318,
    last_avatar: "<null>",
    last_message: "<null>",
    lastname: "Nickson",
    nickname: "anny",
  },
  {
    bio: "<null>",
    email: "user@domain.example",
    firstname: "Muhamed",
    id: 318,
    last_avatar: "<null>",
    last_message: "<null>",
    lastname: "Nickson",
    nickname: "anny",
  },
];

var ar = user.sort(function (a, b) {
  var nA = a.firstname.toLowerCase();
  var nB = b.firstname.toLowerCase();

  if (nA < nB) return -1;
  else if (nA > nB) return 1;
  return 0;
});

如果比较的字符串包含unicode字符，您可以使用String类的localeCompare函数，如下所示:

users.sort(function(a,b){
    return a.firstname.localeCompare(b.firstname);
})

Underscorejs提供了非常好的_。sortBy功能:

_.sortBy([{a:1},{a:3},{a:2}], "a")

或者你可以使用自定义排序函数:

_.sortBy([{a:"b"},{a:"c"},{a:"a"}], function(i) {return i.a.toLowerCase()})

更紧凑的表示法:

user.sort(function(a, b){
    return a.firstname === b.firstname ? 0 : a.firstname < b.firstname ? -1 : 1;
})

您可以使用内置的数组方法-排序。该方法以一个回调方法作为参数

    // custom sort function to be passed as param/callback to the Array's sort method
    function myCustomSort(a, b) {
        return (a.toLowerCase() > b.toLowerCase()) ? 1 : -1;
    }

    // Actual method to be called by entity that needs sorting feature
    function sortStrings() {
        var op = Array.prototype.sort.call(arguments, myCustomSort);
    }

    // Testing the implementation
    var sortedArray = sortStrings("Burger", "Mayo1", "Pizza", "boxes", "Apples", "Mayo");
    console.log(sortedArray); //["Apples", "boxes", "Burger", "Mayo", "Mayo1", "Pizza"]

理解这段代码需要注意的要点。

在本例中，自定义方法myCustomSort应该为每个元素对(来自输入数组)比较返回+1或-1。 在自定义排序回调方法中使用toLowerCase()/toUpperCase()，这样大小写差异不会影响排序过程的正确性。

我希望这个解释足够清楚。如果你认为需要更多信息，请随意评论。

干杯!

你可以使用类似的方法来消除区分大小写的问题

users.sort(function(a, b){

  //compare two values
  if(a.firstname.toLowerCase() < b.firstname.toLowerCase()) return -1;
  if(a.firstname.toLowerCase() > b.firstname.toLowerCase()) return 1;
  return 0;

})

把最上面的答案推到一个原型中按键排序。

Array.prototype.alphaSortByKey= function (key) {
    this.sort(function (a, b) {
        if (a[key] < b[key])
            return -1;
        if (a[key] > b[key])
            return 1;
        return 0;
    });
    return this;
};

漂亮的小ES6内衬:

users.sort((a, b) => a.firstname !== b.firstname ? a.firstname < b.firstname ? -1 : 1 : 0);

使用ES6的最短代码!

users.sort((a, b) => a.firstname.localeCompare(b.firstname))

String.prototype.localeCompare()基本支持是通用的!

简单地说，你可以使用这种方法

users.sort(function(a,b){return a.firstname < b.firstname ? -1 : 1});

您可以将此用于对象

transform(array: any[], field: string): any[] {
return array.sort((a, b) => a[field].toLowerCase() !== b[field].toLowerCase() ? a[field].toLowerCase() < b[field].toLowerCase() ? -1 : 1 : 0);}

我们可以使用localeCompare，但也需要检查键是否有假值

如果一个条目缺少lname，下面的代码将无法工作。

obj.sort((a, b) => a.lname.localeCompare(b.lname))

所以我们需要检查如下所示的假值

让obj = [ {名称:“约翰”,lname:“母鹿”,地址:“阿拉斯加”}, {lname名字:“汤姆”:“希望”,地址:“加州”}, {名称:“哈利”,地址:“德州”} ］ 让字段=“lname”; console.log (obj。sort((a, b) => (a[field] || ""). tostring()。localeCompare((b[field] || "").toString())));

OR

我们可以使用lodash，非常简单。它将检测返回值，即数字或字符串，并相应地进行排序。

import sortBy from 'lodash/sortBy';
sortBy(obj,'name')

https://lodash.com/docs/4.17.5#sortBy

受到这个答案的启发，

users.sort((a,b) => (a.firstname  - b.firstname));

同样，对于asec和desc排序，你可以使用这个: 假设我们有一个变量SortType，指定你想要的升序排序或降序排序:

 users.sort(function(a,b){
            return   sortType==="asc"? a.firstName.localeCompare( b.firstName): -( a.firstName.localeCompare(  b.firstName));
        })

如果我们要对名称或具有特殊字符的东西进行排序，比如ñ或áéíóú(西班牙语中的commons)，我们可以使用params locales(在这种情况下，es代表西班牙语)和如下选项:

让用户=[{“firstname”:“Az”},{“firstname”:“Ab”},{“firstname”:“唉”},{“firstname”:“Na”},{“firstname”:“新西兰”},{“firstname”:“纽约”}); 用户。sort((a, b) => a.firstname. localecompare (b。名字，'es'，{灵敏度:'base'})) console.log(用户)

官方的语言环境选项可以在这里找到iana, es(西班牙语)，de(德语)，fr(法语)。关于灵敏度基数的意思是:

只有基本字母不同的字符串比较为不相等。例如:a≠b, a = á， a = a。

一个广义函数可以这样写

    function getSortedData(data, prop, isAsc) {
        return data.sort((a, b) => (a[prop] < b[prop] ? -1 : 1) * (isAsc ? 1 : -1));
   }

您可以传递以下参数

要排序的数据 数据中的属性应该按它排序 最后一个参数为布尔类型。它检查你是要升序排序还是降序排序

try

users.sort((a,b)=> (a.firstname>b.firstname)*2-1)

Var用户= [ {firstname:“Kate”，id: 318， /*…* /}, {名字:“安娜”，id: 319， /*…* /}, {名字:“christine”，id: 317， /*…* /}, ］ Console.log (users.sort((a,b)=> (a.firstname>b.firstname)*2-1));

我的实现，在旧的ES版本中工作得很好:

sortObject = function(data) {
    var keys = Object.keys(data);
    var result = {};

    keys.sort();

    for(var i = 0; i < keys.length; i++) {
        var key = keys[i];

        result[key] = data[key];
    }

    return result;
};

只是为了记录，如果你想有一个命名排序函数，语法如下:

let sortFunction = (a, b) => {
 if(a.firstname < b.firstname) { return -1; }
 if(a.firstname > b.firstname) { return 1; }
 return 0;
})
users.sort(sortFunction)

请注意，以下是无效的:

users.sort(sortFunction(a,b))

我很惊讶居然没人提到Collators。除非迫不得已，否则不应该使用localeCompare，因为它的性能明显较差

const collator = new Intl.Collator('zh-CN'); // Chinese Simplified for example

function sortAsc(a, b) {
  if (typeof a === 'string' && typeof b === 'string') {
    return collator.compare(b, a)
  }

  return b - a;
}

function sortDesc(a, b) {
  if (typeof a === 'string' && typeof b === 'string') {
    return collator.compare(a, b);
  }

  return a - b;
}

对于一个双因素排序(姓名和姓氏):

用户。sort((a, b) => a.name. tolowercase () < b.name. tolowercase () ?-1: a.name.toLowerCase() > b.name.toLowerCase() ?1: a.lastname.toLowerCase() < b.lastname.toLowerCase() ?-1: a.lastname.toLowerCase() > b.lastname.toLowerCase() ?1: 0)