此排序功能可用于所有对象排序：

对象deepObject（深度对象）数字数组

您还可以通过传递1，-1作为参数进行升序或降序排序。

Object.defineProperty（Object.prototype，'deepVal'{可枚举：false，可写：true，值：函数（propertyChain）{var level=propertyChain.split（'.'）；父项=此项；对于（var i=0；i<levels.length；i++）{if（！parent[levels[i]]）返回未定义；parent=父[级别[i]]；}返回父项；}});函数dynamicSortAll（属性，sortOrders=1）{/**默认排序为升序。如果你需要按降序排序传递-1作为参数**/var sortOrder=sortOrders；返回函数（a，b）{var result=（属性？（（a.deepVal（属性）>b.deepVal（属性））？1：（a.deepVal（属性）<b.deepVal（属性））-1:0）：（（a>b）？1：（a<b）-1 : 0))返回结果*sortOrder；}}深度对象=[{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}}];let deepobjResult=deepObj.sort（dynamicSortAll（'a.a'，1））console.log（'deepobjResult:'+JSON.stringify（deepojResult））变量obj=[{first_nom:'Lazslo'，last_nom:'Jamf'}，{first_nom:'猪'，last_nom:'Bodine'}，｛first_nom:'海盗'，last_nom:'Prentice'｝];let objResult=obj.sort（dynamicSortAll（'last_nom'，1））console.log（'objResult:'+JSON.stringify（objResult））var numericObj=[1，2，3，4，5，6]let numResult=numericObj.sort（dynamicSortAll（null，-1））console.log（'numResult:'+JSON.stringify（numResult））let stringSortResult='helloworld'.split（''）.sort（dynamicSortAll（null，1））console.log（'stringSortResult:'+JSON.stringify（stringSortResult））let uniqueStringOrger=[…new Set（stringSortResult）]；console.log（'uniqueStringOrger:'+JSON.stringify（uniqueStringOrger））

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

let propName = 'last_nom';

let sorted_obj = objs.sort((a,b) => {
    if(a[propName] > b[propName]) {
        return 1;
    }
    if (a[propName] < b[propName]) {
        return -1;
    }
    return 0;
}

//This works because the js built-in sort function allows us to define our
//own way of sorting, this funny looking function is simply telling `sort` how to
//determine what is larger. 
//We can use `if(a[propName] > b[propName])` because string comparison is already built into JS
//if you try console.log('a' > 'z' ? 'a' : 'z')
//the output will be 'z' as 'a' is not greater than 'z'
//The return values 0,-1,1 are how we tell JS what to sort on. We're sorting on the last_nom property of the object. 
//When sorting a list it comes down to comparing two items and how to determine which one of them is "larger". 
//We need a way to tell JS how to determine which one is larger. 
//The sort defining function will use the case that returns a 1 to mean that a > b
//and the case that returns -1 to mean that a < b

使用Lodash或Undercore.js，这是小菜一碟：

const sortedList = _.orderBy(objs, [last_nom], [asc]); // Ascending or descending

您可以使用最简单的方式：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Ö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中查看完整的脚本。