这是《JavaScript:TheGoodParts》一书中优雅实现的一个略微修改版本。

注意：此版本的by是稳定的。它在执行下一个链式排序时保留第一个排序的顺序。

我给它添加了isAscending参数。还将它转换为ES6标准和作者推荐的“更新”好部件。

您可以按多个财产进行升序排序、降序排序和链式排序。

const by=函数（name，minor，isAscending=true）{constreverseMultliplier=isAscending？1 : -1;返回函数（o，p）{设a，b；let结果；if（o&&p&&typeof o==“object”&&typeof p===“object”）{a=o[名称]；b=p[名称]；如果（a===b）{返回minor类型==“函数”？小调（o，p）：0；}if（a的类型==b的类型）{结果=a<b-1 : 1;}其他{结果=a的类型<b的类型-1 : 1;}返回结果*reverseMultilier；}其他{投掷，投掷{name:“错误”，消息：“按+name排序时需要一个对象”};}};};设s=[{first:“乔”，last:“贝瑟”}，{first:“Moe”，last:“Howard”}，{first:“Joe”，last:“DeRita”}，{first:“Shemp”，last:“Howard”}，{first:“Larry”，last:“Fine”}，{第一个：“卷毛”，最后一个：“霍华德”}];//排序方式：第一个升序，最后一个升序s.sort（按（“first”，按（“last”）））；console.log（“排序方式：第一个升序，最后一个升序：”，s）；//"[//{“第一”：“卷毛”，“最后”：“霍华德”}，//{“第一”：“乔”，“最后”：“贝瑟”}<======//{“第一”：“乔”，“最后”：“德丽塔”}<======//{“第一”：“拉里”，“最后”：“好”}，//{“第一”：“莫”，“最后”：“霍华德”}，//{“first”：“Shemp”，“last”：”Howard“}// ]//排序方式：第一个升序，最后一个降序s.sort（按（“first”，按（“last”，0，false）））；console.log（“排序方式：第一个升序，最后一个降序：”，s）；//"[//{“第一”：“卷毛”，“最后”：“霍华德”}，//{“第一”：“乔”，“最后”：“德丽塔”}<========//{“第一”：“乔”，“最后”：“贝瑟”}<========//{“第一”：“拉里”，“最后”：“好”}，//{“第一”：“莫”，“最后”：“霍华德”}，//{“first”：“Shemp”，“last”：”Howard“}// ]

使用lodash.sortBy（使用commonjs的说明，您也可以将cdn的脚本include标记放在html的顶部）

var sortBy = require('lodash.sortby');
// or
sortBy = require('lodash').sortBy;

降序

var descendingOrder = sortBy( homes, 'price' ).reverse();

升序

var ascendingOrder = sortBy( homes, 'price' );

虽然仅对单个数组进行排序有点过分，但该原型函数允许使用点语法按任何键（包括嵌套键）按升序或降序对Javascript数组进行排序。

(function(){
    var keyPaths = [];

    var saveKeyPath = function(path) {
        keyPaths.push({
            sign: (path[0] === '+' || path[0] === '-')? parseInt(path.shift()+1) : 1,
            path: path
        });
    };

    var valueOf = function(object, path) {
        var ptr = object;
        for (var i=0,l=path.length; i<l; i++) ptr = ptr[path[i]];
        return ptr;
    };

    var comparer = function(a, b) {
        for (var i = 0, l = keyPaths.length; i < l; i++) {
            aVal = valueOf(a, keyPaths[i].path);
            bVal = valueOf(b, keyPaths[i].path);
            if (aVal > bVal) return keyPaths[i].sign;
            if (aVal < bVal) return -keyPaths[i].sign;
        }
        return 0;
    };

    Array.prototype.sortBy = function() {
        keyPaths = [];
        for (var i=0,l=arguments.length; i<l; i++) {
            switch (typeof(arguments[i])) {
                case "object": saveKeyPath(arguments[i]); break;
                case "string": saveKeyPath(arguments[i].match(/[+-]|[^.]+/g)); break;
            }
        }
        return this.sort(comparer);
    };    
})();

用法：

var data = [
    { name: { first: 'Josh', last: 'Jones' }, age: 30 },
    { name: { first: 'Carlos', last: 'Jacques' }, age: 19 },
    { name: { first: 'Carlos', last: 'Dante' }, age: 23 },
    { name: { first: 'Tim', last: 'Marley' }, age: 9 },
    { name: { first: 'Courtney', last: 'Smith' }, age: 27 },
    { name: { first: 'Bob', last: 'Smith' }, age: 30 }
]

data.sortBy('age'); // "Tim Marley(9)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Bob Smith(30)"

按具有点语法或数组语法的嵌套财产排序：

data.sortBy('name.first'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy(['name', 'first']); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"

按多个键排序：

data.sortBy('name.first', 'age'); // "Bob Smith(30)", "Carlos Jacques(19)", "Carlos Dante(23)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"
data.sortBy('name.first', '-age'); // "Bob Smith(30)", "Carlos Dante(23)", "Carlos Jacques(19)", "Courtney Smith(27)", "Josh Jones(30)", "Tim Marley(9)"

您可以分叉回购：https://github.com/eneko/Array.sortBy

你需要两个功能

function desc(a, b) {
 return b < a ? -1 : b > a ? 1 : b >= a ? 0 : NaN;
}

function asc(a, b) {
  return a < b ? -1 : a > b ? 1 : a >= b ? 0 : NaN;
}

然后可以将其应用于任何对象属性：

 data.sort((a, b) => desc(parseFloat(a.price), parseFloat(b.price)));

让数据=[{label:“一”，值：10}，{label:“two”，值：5}，｛label:“three”，值：1｝，];//排序函数函数desc（a，b）{返回b<a-1:b>a？1:b>=a？0:NaN；}函数asc（a，b）{返回a<b-1:a>b？1:a>=b？0:NaN；}//描述（DESC）data.sort（（a，b）=>desc（a.value，b.value））；document.body.insert相邻HTML('之前'，'<strong>DESC排序</strong><pre>'+JSON.stringify（数据）+'</pre>');//美国科学院data.sort（（a，b）=>asc（a.value，b.value））；document.body.insert相邻HTML('之前'，'<strong>ASCending sorted</strong><pre>'+JSON.stringify（数据）+'</pre>');

有了ECMAScript 6，StoBor的答案可以更加简洁：

homes.sort((a, b) => a.price - b.price)

一个简单的代码：

var家=[{“h_id”：“3”，“城市”：“达拉斯”，“状态”：“TX”，“zip”：“75201”，“价格”：“162500”}, {“h_id”：“4”，“城市”：“贝弗利山”，“状态”：“CA”，“zip”：“90210”，“price”：“319250”}, {“h_id”：“5”，“城市”：“纽约”，“州”：“NY”，“zip”：“00010”，“价格”：“962500”}];let sortByPrice=homes.sort（函数（a，b）{return parseFloat（b.price）-parseFlat（a.price）；});对于（var i=0；i＜sortByPrice.length；i++）{document.write（sortByPrice[i].h-id+“”+sortByPrice[i].city+“”+按价格排序[i].state+''+sortByPrice[i].zip+“”+sortByPrice[i].price）；document.write（“<br>”）；}