这是一个简单的问题。我不知道为什么人们会有如此复杂的解决方案。

一个简单的排序函数（基于快速排序算法）：

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

如果你有重复的姓氏，你可以按名字排序-

obj.sort(function(a,b){
  if(a.last_nom< b.last_nom) return -1;
  if(a.last_nom >b.last_nom) return 1;
  if(a.first_nom< b.first_nom) return -1;
  if(a.first_nom >b.first_nom) return 1;
  return 0;
});

我一直在各种项目中使用这个实用程序，而且效果很好。它也非常模块化：

传递要排序的键的名称选择排序是升序还是降序

按KeyUtil.js排序对象数组

// Sort array of objects by key
// ------------------------------------------------------------
const sortArrayOfObjsByKey = (array, key, ascdesc) =>
  array.sort((a, b) => {
    const x = a[key];
    const y = b[key];
    if (ascdesc === 'asc') {
      return x < y ? -1 : x > y ? 1 : 0;
    }
    if (ascdesc === 'desc') {
      return x > y ? -1 : x < y ? 1 : 0;
    }
    return null;
  });

按KeyUtil.test.js排序对象数组

import sortArrayOfObjsByKey from './sortArrayOfObjsByKeyUtil';

const unsortedArray = [
  {
    _id: '3df55221-ce5c-4147-8e14-32effede6133',
    title: 'Netlife Design',
    address: {
      PostalAddress: {
        streetAddress: 'Youngstorget 3',
        addressLocality: 'Oslo',
        addressRegion: null,
        postalCode: '0181',
        addressCountry: 'Norway',
      },
    },
    geopoint: { lat: 59.914322, lng: 10.749272 },
  },
  {
    _id: 'cd00459f-3755-49f1-8847-66591ef935b2',
    title: 'Home',
    address: {
      PostalAddress: {
        streetAddress: 'Stockfleths gate 58A',
        addressLocality: 'Oslo',
        addressRegion: null,
        postalCode: '0461',
        addressCountry: 'Norway',
      },
    },
    geopoint: { lat: 59.937316, lng: 10.751862 },
  },
];

const sortedArray = [
  {
    _id: 'cd00459f-3755-49f1-8847-66591ef935b2',
    title: 'Home',
    address: {
      PostalAddress: {
        streetAddress: 'Stockfleths gate 58A',
        addressLocality: 'Oslo',
        addressRegion: null,
        postalCode: '0461',
        addressCountry: 'Norway',
      },
    },
    geopoint: { lat: 59.937316, lng: 10.751862 },
  },
  {
    _id: '3df55221-ce5c-4147-8e14-32effede6133',
    title: 'Netlife Design',
    address: {
      PostalAddress: {
        streetAddress: 'Youngstorget 3',
        addressLocality: 'Oslo',
        addressRegion: null,
        postalCode: '0181',
        addressCountry: 'Norway',
      },
    },
    geopoint: { lat: 59.914322, lng: 10.749272 },
  },
];

describe('sortArrayOfObjsByKey', () => {
  it(`sort array by 'title' key, ascending`, () => {
    const testInput = sortArrayOfObjsByKey(unsortedArray, 'title', 'asc');
    const testOutput = sortedArray;
    expect(testInput).toEqual(testOutput);
  });
});

简单答案：

objs.sort((a,b)=>a.last_nom.localeCompare(b.last_nom))

细节：

今天非常简单，您可以将字符串与localeCompare进行比较。正如Mozilla Doc所说：

localeCompare（）方法返回一个数字，指示引用字符串在排序顺序上位于给定字符串之前、之后或与给定字符串相同。

    //example1:
    console.log("aaa".localeCompare("aab")); //-1
    console.log("aaa".localeCompare("aaa")); //0
    console.log("aab".localeCompare("aaa")); //1

    //example2:
    const a = 'réservé'; // with accents, lowercase
    const b = 'RESERVE'; // no accents, uppercase

    console.log(a.localeCompare(b));
    // expected output: 1
    console.log(a.localeCompare(b, 'en', { sensitivity: 'base' }));
    // expected output: 0

有关详细信息，请参阅Mozilla doclocaleCompare：

我刚刚增强了EgeÖzcan的动态分类，可以深入物体内部。

如果数据如下所示：

obj = [
    {
        a: { a: 1, b: 2, c: 3 },
        b: { a: 4, b: 5, c: 6 }
    },
    {
        a: { a: 3, b: 2, c: 1 },
        b: { a: 6, b: 5, c: 4 }
}];

如果你想在a.a属性中进行排序，我认为我的增强功能非常有用。我向以下对象添加了新功能：

Object.defineProperty(Object.prototype, 'deepVal', {
    enumerable: false,
    writable: true,
    value: function (propertyChain) {
        var levels = propertyChain.split('.');
        parent = this;
        for (var i = 0; i < levels.length; i++) {
            if (!parent[levels[i]])
                return undefined;
            parent = parent[levels[i]];
        }
        return parent;
    }
});

并更改了_dynamicSort的返回函数：

return function (a, b) {
    var result = ((a.deepVal(property) > b.deepVal(property)) - (a.deepVal(property) < b.deepVal(property)));
    return result * sortOrder;
}

现在你可以这样按a.a.排序：

obj.sortBy('a.a');

在JSFiddle中查看完整的脚本。

Deep

基于这篇优秀的教程，我想开发Vlad Bezden的答案，并解释为什么localeCompare优于标准比较方法，如strA>strB。让我们运行以下示例：

console.log（“Österreich”>“Zealand”）；//我们期望错误console.log（“a”>“Z”）；//我们期望错误

原因是在JavaScript中，所有字符串都使用UTF-16编码

让str=“”；//JavaScript中的字符顺序for（设i=65；i<=220；i++）{str+=字符串.fromCodePoint（i）；//代码到字符}console.log（str）；

首先是大写字母（有小代码），然后是小写字母，然后是字符Ö（在z之后）。这就是为什么我们在第一个代码段中得到正确的原因，因为运算符>比较字符代码。

如您所见，比较不同语言中的字符是一项非常重要的任务，但幸运的是，现代浏览器支持国际化标准ECMA-402。所以在JavaScript中，我们有strA.localeCompare（strB）来完成任务（-1表示strA小于strB；1表示相反；0表示相等）

console.log（'Österreich'.localeCompare（'Zealand'））；//我们期望-1console.log（'a'.localeCompare（'Z'））；//我们期望-1

我想补充一点，localeCompare支持两个参数：语言和其他规则：

var对象=[{first_nom:'Lazslo'，last_nom:'Jamf'}，{first_nom:'猪'，last_nom:'Bodine'}，{first_nom:'海盗'，last_nom:'Prentice'}，｛first_nom:'测试'，last_nom:'jamf'｝];objs.sort（（a，b）=>a.last_nom.localeCompare（b.last_nom，'en'，{sensitity:'case'}））console.log（objs）；//在'>'比较中，'Jamf'不会在'Jamf'旁边