Lodash（Undercore.js的超集）。

不为每一个简单的逻辑添加一个框架是很好的，但是依赖于经过良好测试的实用程序框架可以加快开发并减少错误数量。

Lodash生成了非常干净的代码，并促进了更具功能性的编程风格。一眼望去，代码的意图就一目了然了。

OP的问题可以简单地解决为：

const sortedObjs = _.sortBy(objs, 'last_nom');

更多信息？例如，我们有以下嵌套对象：

const users = [
  { 'user': {'name':'fred', 'age': 48}},
  { 'user': {'name':'barney', 'age': 36 }},
  { 'user': {'name':'wilma'}},
  { 'user': {'name':'betty', 'age': 32}}
];

我们现在可以使用_.properties速记user.age来指定应该匹配的属性的路径。我们将根据嵌套的年龄属性对用户对象进行排序。是的，它允许嵌套属性匹配！

const sortedObjs = _.sortBy(users, ['user.age']);

想要反转吗？没问题。使用_反向。

const sortedObjs = _.reverse(_.sortBy(users, ['user.age']));

想用链条将两者结合起来吗？

const { chain } = require('lodash');
const sortedObjs = chain(users).sortBy('user.age').reverse().value();

或者你什么时候更喜欢流动而不是链条？

const { flow, reverse, sortBy } = require('lodash/fp');
const sortedObjs = flow([sortBy('user.age'), reverse])(users);

您可以使用最简单的方式：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']);

将Ege的动态解决方案与Vinay的想法相结合，您可以得到一个很好的鲁棒解决方案：

Array.prototype.sortBy=函数（）{函数_sortByAttr（属性）{var sortOrder=1；如果（属性[0]==“-”）{sortOrder=-1；attr=attr.substr（1）；}返回函数（a，b）{var结果=（a[attr]<b[attr]）-1：（a[attr]>b[attr]）？1 : 0;返回结果*sortOrder；}}函数_getSortFunc（）{if（arguments.length==0）{throw“Array.sortBy（）不允许零长度参数”；}var args=参数；返回函数（a，b）{for（var result=0，i=0；result==0&&i<args.length；i++）{result=_sortByAttr（args[i]）（a，b）；}返回结果；}}返回this.sort（_getSortFunc.apply（null，arguments））；}用法：//用于打印对象的实用程序Array.prototype.print=函数（标题）{console.log（“************************************************************”）；console.log（“***”+标题）；console.log（“************************************************************”）；对于（var i=0；i<this.length；i++）{console.log（“名称：”+此[i].FirstName，此[i].LastName，“年龄：”+该[i].Age）；}}//设置示例数据变量arrObj=[{名字：“Zach”，姓氏：“Emergency”，年龄：35岁},{名字：“Nancy”，姓氏：“护士”，年龄：27岁},{名字：“Ethel”，姓氏：“Emergency”，年龄：42岁},{名字：“Nina”，姓氏：“护士”，年龄：48岁},{名字：“Anthony”，姓氏：“Emergency”，年龄：44岁},{名字：“Nina”，姓氏：“护士”，年龄：32岁},{名字：“Ed”，姓氏：“Emergency”，年龄：28岁},{名字：“Peter”，姓氏：“医生”，年龄：58岁},{名字：“Al”，姓氏：“Emergency”，年龄：51岁},{名字：“Ruth”，姓氏：“注册”，年龄：62岁},{名字：“Ed”，姓氏：“Emergency”，年龄：38岁},{名字：“Tammy”，姓氏：“Triage”，年龄：29岁},{名字：“Alan”，姓氏：“Emergency”，年龄：60岁},{名字：“Nina”，姓氏：“护士”，年龄：54岁}];//单元测试arrObj.sortBy（“姓氏”）.print（“姓氏升序”）；arrObj.sortBy（“-姓氏”）.print（“姓氏降序”）；arrObj.sortBy（“姓氏”、“名字”、“年龄”）.print（“姓氏升序、名字升序、年龄降序”）；arrObj.sortBy（“-FirstName”，“Age”）.print（“FirstName降序，Age升序”）；arrObj.sortBy（“-Age”）.print（“Age Descending”）；

您可能需要将它们转换为小写形式，以防止混淆。

objs.sort(function (a, b) {

    var nameA = a.last_nom.toLowerCase(), nameB = b.last_nom.toLowerCase()

    if (nameA < nameB)
      return -1;
    if (nameA > nameB)
      return 1;
    return 0;  // No sorting
})

不正确的旧答案：

arr.sort((a, b) => a.name > b.name)

更新

博尚的评论：

arr.sort((a, b) => a.name < b.name ? -1 : (a.name > b.name ? 1 : 0))

更可读的格式：

arr.sort((a, b) => {
  if (a.name < b.name) return -1
  return a.name > b.name ? 1 : 0
})

没有嵌套的三元组：

arr.sort((a, b) => a.name < b.name ? - 1 : Number(a.name > b.name))

说明：Number（）将强制为true，并强制为false。

我刚刚增强了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中查看完整的脚本。