它对我有用。在这里，它将一直保持未定义状态。

函数排序（项、属性、方向）{函数比较（a，b）{if（！a[property]&&！b[property]）{返回0；}否则如果（a[property]&&！b[property]）{返回-1；}否则如果（！a[property]&&b[property]）{返回1；}其他{const value1=a[property].toString（）.toUpperCase（）；//忽略大小写const value2=b[property].toString（）.toUpperCase（）；//忽略大小写如果（值1<值2）{返回方向==0-1 : 1;}否则如果（值1>值2）{返回方向==0？1 : -1;}其他{返回0；}}}返回项目。排序（比较）；} 变量项=[{名称：'Edward'，值：21}，｛name:“Sharpe”，值：37｝，｛name:“And”，值：45｝，｛name:“The”，值：-12｝，｛名称：未定义，值：-12｝，｛name:“Magnetic”，值：13｝，｛name:“Zeros”，值：37｝];console.log（'场景顺序：-'）；console.log（排序（项，'name'，0））；console.log（'下订单：-'）；console.log（排序（项，'name'，1））；

排序（更多）复杂的对象阵列

由于您可能会遇到类似于此阵列的更复杂的数据结构，因此我将扩展解决方案。

TL；博士

是基于@ege-Özcan非常可爱的答案的更可插拔版本。

问题

我遇到了下面的问题，无法更改它。我也不想暂时压平对象。我也不想使用下划线/lodash，主要是出于性能原因和自己实现它的乐趣。

var People = [
   {Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
   {Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
   {Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];

Goal

目标是主要按People.Name.Name排序，其次按People.Name.surname排序

障碍

现在，在基本解决方案中，使用括号表示法来计算要动态排序的财产。不过，在这里，我们还必须动态地构造括号表示法，因为您可能会期望像People['Name.Name']这样的符号会起作用，但这不起作用。

另一方面，简单地做人物['Name']['Name']是静态的，只允许你进入第n层。

解决方案

这里的主要添加是遍历对象树并确定最后一个叶以及任何中间叶的值。

var People = [
   {Name: {name: "Name", surname: "Surname"}, Middlename: "JJ"},
   {Name: {name: "AAA", surname: "ZZZ"}, Middlename:"Abrams"},
   {Name: {name: "Name", surname: "AAA"}, Middlename: "Wars"}
];

People.sort(dynamicMultiSort(['Name','name'], ['Name', '-surname']));
// Results in...
// [ { Name: { name: 'AAA', surname: 'ZZZ' }, Middlename: 'Abrams' },
//   { Name: { name: 'Name', surname: 'Surname' }, Middlename: 'JJ' },
//   { Name: { name: 'Name', surname: 'AAA' }, Middlename: 'Wars' } ]

// same logic as above, but strong deviation for dynamic properties 
function dynamicSort(properties) {
  var sortOrder = 1;
  // determine sort order by checking sign of last element of array
  if(properties[properties.length - 1][0] === "-") {
    sortOrder = -1;
    // Chop off sign
    properties[properties.length - 1] = properties[properties.length - 1].substr(1);
  }
  return function (a,b) {
    propertyOfA = recurseObjProp(a, properties)
    propertyOfB = recurseObjProp(b, properties)
    var result = (propertyOfA < propertyOfB) ? -1 : (propertyOfA > propertyOfB) ? 1 : 0;
    return result * sortOrder;
  };
}

/**
 * Takes an object and recurses down the tree to a target leaf and returns it value
 * @param  {Object} root - Object to be traversed.
 * @param  {Array} leafs - Array of downwards traversal. To access the value: {parent:{ child: 'value'}} -> ['parent','child']
 * @param  {Number} index - Must not be set, since it is implicit.
 * @return {String|Number}       The property, which is to be compared by sort.
 */
function recurseObjProp(root, leafs, index) {
  index ? index : index = 0
  var upper = root
  // walk down one level
  lower = upper[leafs[index]]
  // Check if last leaf has been hit by having gone one step too far.
  // If so, return result from last step.
  if (!lower) {
    return upper
  }
  // Else: recurse!
  index++
  // HINT: Bug was here, for not explicitly returning function
  // https://stackoverflow.com/a/17528613/3580261
  return recurseObjProp(lower, leafs, index)
}

/**
 * Multi-sort your array by a set of properties
 * @param {...Array} Arrays to access values in the form of: {parent:{ child: 'value'}} -> ['parent','child']
 * @return {Number} Number - number for sort algorithm
 */
function dynamicMultiSort() {
  var args = Array.prototype.slice.call(arguments); // slight deviation to base

  return function (a, b) {
    var i = 0, result = 0, numberOfProperties = args.length;
    // REVIEW: slightly verbose; maybe no way around because of `.sort`-'s nature
    // Consider: `.forEach()`
    while(result === 0 && i < numberOfProperties) {
      result = dynamicSort(args[i])(a, b);
      i++;
    }
    return result;
  }
}

实例

JSBin的工作示例

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'旁边

这里有很多好的答案，但我想指出，它们可以非常简单地扩展，以实现更复杂的排序。您必须做的唯一一件事就是使用OR运算符来链接比较函数，如下所示：

objs.sort((a,b)=> fn1(a,b) || fn2(a,b) || fn3(a,b) )

其中fn1，fn2。。。是返回[-1,0,1]的排序函数。这导致“按fn1排序”和“按fn2排序”，这在SQL中相当于ORDERBY。

此解决方案基于||运算符的行为，该运算符的求值结果为第一个可转换为true的求值表达式。

最简单的表单只有一个这样的内联函数：

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

使用last_nom和first_nom排序顺序有两个步骤，如下所示：

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> a.last_nom.localeCompare(b.last_nom) ||
                  a.first_nom.localeCompare(b.first_nom)  )

通用比较函数可以是这样的：

// ORDER BY <n>
let cmp = (a,b,n)=>a[n].localeCompare(b[n])

此函数可以扩展为支持数字字段、区分大小写、任意数据类型等。

您可以通过按排序优先级链接它们来使用它们：

// ORDER_BY last_nom, first_nom
objs.sort((a,b)=> cmp(a,b, "last_nom") || cmp(a,b, "first_nom") )
// ORDER_BY last_nom, first_nom DESC
objs.sort((a,b)=> cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )
// ORDER_BY last_nom DESC, first_nom DESC
objs.sort((a,b)=> -cmp(a,b, "last_nom") || -cmp(a,b, "first_nom") )

这里的重点是，采用函数方法的纯JavaScript可以在没有外部库或复杂代码的情况下走很长的路。它也非常有效，因为不需要进行字符串解析。

根据您的示例，您需要按两个字段（姓、名）排序，而不是一个。您可以使用Alasql库在一行中进行排序：

var res = alasql('SELECT * FROM ? ORDER BY last_nom, first_nom',[objs]);

在JSFiddle中尝试此示例。

我遇到了排序对象数组的问题，改变了值的优先级。基本上，我想按年龄，然后按姓氏，或者仅仅按姓氏，名字来对一系列人进行排序。

我认为与其他答案相比，这是最简单的解决方案。

它用于调用sortPeoples（['array'，'of'，'properties']，reverse=false）。

///////////////////////人群示例阵列///////////////////////var人民=[{姓名：“Zach”，姓：“Emergency”，年龄：1}，{姓名：“南希”，姓：“护士”，年龄：1岁}，{姓名：“Ethel”，姓：“Emergency”，年龄：1}，{姓名：“尼娜”，姓：“护士”，年龄：42岁}，{姓名：“Anthony”，姓：“Emergency”，年龄：42岁}，{姓名：“尼娜”，姓：“护士”，年龄：32岁}，{姓名：“Ed”，姓：“Emergency”，年龄：28岁}，{姓名：“彼得”，姓：“医生”，年龄：58岁}，{姓名：“Al”，姓：“Emergency”，年龄：58岁}，{姓名：“Ruth”，姓：“Registration”，年龄：62岁}，{姓名：“Ed”，姓：“Emergency”，年龄：38岁}，{姓名：“Tammy”，姓：“Triage”，年龄：29岁}，{姓名：“Alan”，姓：“Emergency”，年龄：60岁}，{姓名：“尼娜”，姓：“护士”，年龄：58岁}];////////////////////////排序功能/////////////////////函数sortPeoples（propertyArr，reverse）{函数比较（a，b）{变量i=0；while（propertyArr[i]）{如果（a[propertyArr[i]]<b[propertyAr[i]]）返回-1；如果（a[propertyArr[i]]>b[propertyAr[i]]）返回1；i++；}返回0；}人民。排序（比较）；if（反向）{peoples.reverse（）；}};////////////////排序方法结束///////////////函数printPeoples（）{$（“#输出”）.html（“”）；people.forEach（功能（人）{$（'#output'）.append（person.surname+“”+person.name+““”+person.age+“<br>”）；})}<head><script src=“https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js“></script></head><html><body><button onclick=“sortPeoples（['surname']）；printPeoples（）”>仅按姓氏ASC排序会导致同名案例的混乱</button><br><button onclick=“sortPeoples（['surname'，'name]，true）；printPeoples（）”>按姓氏排序，然后按名称DESC</button><br><button onclick=“sortPeoples（['age']）；printPeoples（）”>按age ASC排序。与第一种情况相同的问题</button><br><button onclick=“sortPeoples（['age'，'姓']）；printPeoples（）”>按age和姓氏ASC排序。添加第二个字段修复了它。</button><br><div id=“output”></div></body></html>