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

您还可以创建一个动态排序函数，根据传递的值对对象进行排序：

function dynamicSort(property) {
    var sortOrder = 1;
    if(property[0] === "-") {
        sortOrder = -1;
        property = property.substr(1);
    }
    return function (a,b) {
        /* next line works with strings and numbers, 
         * and you may want to customize it to your needs
         */
        var result = (a[property] < b[property]) ? -1 : (a[property] > b[property]) ? 1 : 0;
        return result * sortOrder;
    }
}

所以你可以有一个这样的对象数组：

var People = [
    {Name: "Name", Surname: "Surname"},
    {Name:"AAA", Surname:"ZZZ"},
    {Name: "Name", Surname: "AAA"}
];

…当你这样做时，它会起作用：

People.sort(dynamicSort("Name"));
People.sort(dynamicSort("Surname"));
People.sort(dynamicSort("-Surname"));

事实上，这已经回答了问题。下面的部分是因为许多人联系我，抱怨它不适用于多个参数。

多个参数

您可以使用下面的函数生成具有多个排序参数的排序函数。

function dynamicSortMultiple() {
    /*
     * save the arguments object as it will be overwritten
     * note that arguments object is an array-like object
     * consisting of the names of the properties to sort by
     */
    var props = arguments;
    return function (obj1, obj2) {
        var i = 0, result = 0, numberOfProperties = props.length;
        /* try getting a different result from 0 (equal)
         * as long as we have extra properties to compare
         */
        while(result === 0 && i < numberOfProperties) {
            result = dynamicSort(props[i])(obj1, obj2);
            i++;
        }
        return result;
    }
}

这将使您能够执行以下操作：

People.sort(dynamicSortMultiple("Name", "-Surname"));

子类化数组

对于我们中能够使用ES6的幸运者，ES6允许扩展本机对象：

class MyArray extends Array {
    sortBy(...args) {
        return this.sort(dynamicSortMultiple(...args));
    }
}

这将实现：

MyArray.from(People).sortBy("Name", "-Surname");

我会这样做：

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

对对象数组进行排序

// Data
var booksArray = [
    { first_nom: 'Lazslo', last_nom: 'Jamf'     },
    { first_nom: 'Pig',    last_nom: 'Bodine'   },
    { first_nom: 'Pirate', last_nom: 'Prentice' }
];

// Property to sort by
var args = "last_nom";

// Function to sort the data by the given property
function sortByProperty(property) {
    return function (a, b) {
        var sortStatus = 0,
            aProp = a[property].toLowerCase(),
            bProp = b[property].toLowerCase();
        if (aProp < bProp) {
            sortStatus = -1;
        } else if (aProp > bProp) {
            sortStatus = 1;
        }
        return sortStatus;
    };
}

// Implementation
var sortedArray = booksArray.sort(sortByProperty(args));

console.log("sortedArray: " + JSON.stringify(sortedArray) );

控制台日志输出：

"sortedArray: 
[{"first_nom":"Pig","last_nom":"Bodine"},
{"first_nom":"Lazslo","last_nom":"Jamf"},
{"first_nom":"Pirate","last_nom":"Prentice"}]"

基于此来源改编：代码段：如何按属性对JSON对象数组排序

这是我的看法：

order参数是可选的，对于升序，默认为“ASC”。

它适用于重音字符，并且不区分大小写。

注意：它排序并返回原始数组。

function sanitizeToSort(str) {
  return str
    .normalize('NFD')                   // Remove accented and diacritics
    .replace(/[\u0300-\u036f]/g, '')    // Remove accented and diacritics
    .toLowerCase()                      // Sort will be case insensitive
  ;
}

function sortByProperty(arr, property, order="ASC") {
  arr.forEach((item) => item.tempProp = sanitizeToSort(item[property]));
  arr.sort((a, b) => order === "ASC" ?
      a.tempProp > b.tempProp ?  1 : a.tempProp < b.tempProp ? -1 : 0
    : a.tempProp > b.tempProp ? -1 : a.tempProp < b.tempProp ?  1 : 0
  );
  arr.forEach((item) => delete item.tempProp);
  return arr;
}

一小条

函数cleaniteToSort（str）{返回str.normalize（'NFD'）//删除重音字符.replace（/[\u0300-\u036f]/g，“”）//删除变音符号.to小写（）;}函数sortByProperty（arr，property，order=“ASC”）{arr.forEach（（item）=>item.tempProp=消毒排序（item[property]））；arr.sort（（a，b）=>顺序==“ASC”？a.tempProp>b.tempProp？1:a.tempProp<b.tempProp-1 : 0：a.tempProp>b.tempProp-1:a.tempProp<b.tempProp？1 : 0);arr.forEach（（item）=>删除item.tempProp）；返回arr；}常量rockStars=[｛name:“Axl”，姓：“Rose”}，{name:“埃尔顿”，姓：“John”}，{name:“Paul”，姓氏：“McCartney”}，{name:“楼”，姓：“里德”}，｛name:“freddie”，//使用小写/大写姓氏：“mercury”}，｛name:“Ámy”，//也适用于重音字符姓氏：“酒庄”}];sortByProperty（rockStars，“name”）；console.log（“按名称A-Z排序：”）；rockStars.forEach（（item）=>console.log（item.name+“”+item.lastname））；sortByProperty（rockStars，“姓氏”，“DESC”）；console.log（“\n按姓氏Z-A排序：”）；rockStars.forEach（（item）=>console.log（item.lastname+“，”+item.name））；

编写自己的比较函数非常简单：

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

objs.sort( compare );

或内联（由Marco Demaio转交）：

objs.sort((a,b) => (a.last_nom > b.last_nom) ? 1 : ((b.last_nom > a.last_nom) ? -1 : 0))

或简化为数字（由Andre Figueiredo转交）：

objs.sort((a,b) => a.last_nom - b.last_nom); // b - a for reverse sort