警告不建议使用此解决方案，因为它不会导致排序数组。它被留在这里供将来参考，因为这种想法并不罕见。

objs.sort(function(a,b){return b.last_nom>a.last_nom})

当您需要自然排序（即1,2,10,111111）时，使用Intl.Collator对特定情况的对象进行排序。

常量文件=[｛name:“1.mp3”，大小：123｝，｛name:“10.mp3”，大小：456｝，｛name:“100.mp3”，大小：789｝，｛name:“11.mp3”，大小：123｝，｛name:“111.mp3”，大小：456｝，｛name:“2.mp3”，大小：789｝，];const naturalCollator=新Intl.Collator（未定义，｛numeric:true，sensitity:'base'｝）；files.sort（（a，b）=>naturalCollator.compare（a.name，b.name））；console.log（文件）；

浏览器支持Intl.Collator

使用原型继承简单快速地解决此问题：

Array.prototype.sortBy = function(p) {
  return this.slice(0).sort(function(a,b) {
    return (a[p] > b[p]) ? 1 : (a[p] < b[p]) ? -1 : 0;
  });
}

示例/用法

objs = [{age:44,name:'vinay'},{age:24,name:'deepak'},{age:74,name:'suresh'}];

objs.sortBy('age');
// Returns
// [{"age":24,"name":"deepak"},{"age":44,"name":"vinay"},{"age":74,"name":"suresh"}]

objs.sortBy('name');
// Returns
// [{"age":24,"name":"deepak"},{"age":74,"name":"suresh"},{"age":44,"name":"vinay"}]

更新：不再修改原始数组。

如果您有嵌套对象

const objs = [{
        first_nom: 'Lazslo',
        last_nom: 'Jamf',
        moreDetails: {
            age: 20
        }
    }, {
        first_nom: 'Pig',
        last_nom: 'Bodine',
        moreDetails: {
            age: 21
        }
    }, {
        first_nom: 'Pirate',
        last_nom: 'Prentice',
        moreDetails: {
            age: 22
        }
    }];

nestedSort = (prop1, prop2 = null, direction = 'asc') => (e1, e2) => {
        const a = prop2 ? e1[prop1][prop2] : e1[prop1],
            b = prop2 ? e2[prop1][prop2] : e2[prop1],
            sortOrder = direction === "asc" ? 1 : -1
        return (a < b) ? -sortOrder : (a > b) ? sortOrder : 0;
    }

并称之为

objs.sort(nestedSort("last_nom"));
objs.sort(nestedSort("last_nom", null, "desc"));
objs.sort(nestedSort("moreDetails", "age"));
objs.sort(nestedSort("moreDetails", "age", "desc"));

这里有很多好的答案，但我想指出，它们可以非常简单地扩展，以实现更复杂的排序。您必须做的唯一一件事就是使用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可以在没有外部库或复杂代码的情况下走很长的路。它也非常有效，因为不需要进行字符串解析。

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

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