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

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

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

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

所以这里有一种排序算法，它可以在任何类型的对象数组中按任何顺序排序，而不受数据类型比较的限制（如Number、String等）：

function smoothSort(items,prop,reverse) {
    var length = items.length;
    for (var i = (length - 1); i >= 0; i--) {
        //Number of passes
        for (var j = (length - i); j > 0; j--) {
            //Compare the adjacent positions
            if(reverse){
              if (items[j][prop] > items[j - 1][prop]) {
                //Swap the numbers
                var tmp = items[j];
                items[j] = items[j - 1];
                items[j - 1] = tmp;
            }
            }

            if(!reverse){
              if (items[j][prop] < items[j - 1][prop]) {
                  //Swap the numbers
                  var tmp = items[j];
                  items[j] = items[j - 1];
                  items[j - 1] = tmp;
              }
            }
        }
    }

    return items;
}

第一参数项是对象数组，prop是要排序的对象的键，reverse是一个布尔参数，如果为true，则返回升序，如果为false，则返回降序。

我还没有看到这种特别的方法，所以这里有一个我喜欢使用的简洁的比较方法，它适用于字符串和数字类型：

常量对象=[{first_nom:'Lazslo'，last_nom:'Jamf'}，{first_nom:'猪'，last_nom:'Bodine'}，｛first_nom:'海盗'，last_nom:'Prentice'｝];常量排序依据=fn=>{常量cmp=（a，b）=>-（a<b）||+（a>b）；return（a，b）=>cmp（fn（a），fn（b））；};const getLastName=o=>o.last_nom；const sortByLastName=sortBy（getLastName）；objs.sort（sortByLastName）；console.log（objs.map（getLastName））；

sortBy（）的解释

sortBy（）接受一个fn，该fn从一个对象中选择一个值用于比较，并返回一个可以传递给Array.prototype.sort（）的函数。在本例中，我们正在比较o.last_nom。每当我们收到两个对象，例如

a = { first_nom: 'Lazslo', last_nom: 'Jamf' }
b = { first_nom: 'Pig', last_nom: 'Bodine' }

我们将它们与（a，b）=>cmp（fn（a），fn（b））进行比较。鉴于此

fn = o => o.last_nom

我们可以将比较函数扩展为（a，b）=>cmp（a.last_nom，b.last_nom）。由于逻辑OR（||）在JavaScript中的工作方式，cmp（a.last_nom、b.last_nom）相当于

if (a.last_nom < b.last_nom) return -1;
if (a.last_nom > b.last_nom) return 1;
return 0;

顺便说一下，这在其他语言中被称为三向比较“宇宙飞船”（<=>）运算符。

最后，这里是不使用箭头函数的ES5兼容语法：

var对象=[{first_nom:'Lazslo'，last_nom:'Jamf'}，{first_nom:'猪'，last_nom:'Bodine'}，｛first_nom:'海盗'，last_nom:'Prentice'｝];函数sortBy（fn）{函数cmp（a，b）{return-（a＜b）| |+（a＞b）；}返回函数（a，b）{return cmp（fn（a），fn（b））；}；}函数getLastName（o）｛return o.last_nom；｝var sortByLastName=sortBy（getLastName）；objs.sort（sortByLastName）；console.log（objs.map（getLastName））；

在TypeScript中编程时，也可以创建动态排序函数，但在这种情况下，类型变得更加复杂。

function sortByKey<O>(key: keyof O, decending: boolean = false): (a: O, b: O) => number {
    const order = decending ? -1 : 1;
    return (a, b): number => {
        const valA = a[key];
        const valB = b[key];
        if (valA < valB) {
            return -order;
        } else if (valA > valB) {
            return order;
        } else {
            return 0;
        }
    }
}

这可以在TypeScript中使用，如下所示：

const test = [
    {
        id: 0,
    },
    {
        id: 2,
    }
]

test.sort(sortByKey('id')) // OK
test.sort(sortByKey('id1')) // ERROR
test.sort(sortByKey('')) // ERROR