当您需要自然排序（即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

这是一个简单的问题。我不知道为什么人们会有如此复杂的解决方案。

一个简单的排序函数（基于快速排序算法）：

function sortObjectsArray(objectsArray, sortKey)
{
    // Quick Sort:
    var retVal;

    if (1 < objectsArray.length)
    {
        var pivotIndex = Math.floor((objectsArray.length - 1) / 2);  // Middle index
        var pivotItem = objectsArray[pivotIndex];                    // Value in the middle index
        var less = [], more = [];

        objectsArray.splice(pivotIndex, 1);                          // Remove the item in the pivot position
        objectsArray.forEach(function(value, index, array)
        {
            value[sortKey] <= pivotItem[sortKey] ?                   // Compare the 'sortKey' proiperty
                less.push(value) :
                more.push(value) ;
        });

        retVal = sortObjectsArray(less, sortKey).concat([pivotItem], sortObjectsArray(more, sortKey));
    }
    else
    {
        retVal = objectsArray;
    }

    return retVal;
}

使用示例：

var myArr =
        [
            { val: 'x', idx: 3 },
            { val: 'y', idx: 2 },
            { val: 'z', idx: 5 },
        ];

myArr = sortObjectsArray(myArr, 'idx');

我刚刚增强了EgeÖzcan的动态分类，可以深入物体内部。

如果数据如下所示：

obj = [
    {
        a: { a: 1, b: 2, c: 3 },
        b: { a: 4, b: 5, c: 6 }
    },
    {
        a: { a: 3, b: 2, c: 1 },
        b: { a: 6, b: 5, c: 4 }
}];

如果你想在a.a属性中进行排序，我认为我的增强功能非常有用。我向以下对象添加了新功能：

Object.defineProperty(Object.prototype, 'deepVal', {
    enumerable: false,
    writable: true,
    value: function (propertyChain) {
        var levels = propertyChain.split('.');
        parent = this;
        for (var i = 0; i < levels.length; i++) {
            if (!parent[levels[i]])
                return undefined;
            parent = parent[levels[i]];
        }
        return parent;
    }
});

并更改了_dynamicSort的返回函数：

return function (a, b) {
    var result = ((a.deepVal(property) > b.deepVal(property)) - (a.deepVal(property) < b.deepVal(property)));
    return result * sortOrder;
}

现在你可以这样按a.a.排序：

obj.sortBy('a.a');

在JSFiddle中查看完整的脚本。

下划线.js

使用Undercore.js]。它很小，非常棒。。。

sortBy_.sortBy（列表，迭代器，[context]）返回列表，按运行每个值的结果升序排列通过迭代器。迭代器也可以是属性的字符串名称按（例如长度）排序。

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

var sortedObjs = _.sortBy(objs, 'first_nom');

您可以使用最简单的方式：Lodash

(https://lodash.com/docs/4.17.10#orderBy)

此方法类似于_.sortBy，只是它允许指定要排序的迭代项的排序顺序。如果未指定顺序，则所有值都按升序排序。否则，为相应值的降序指定“desc”，为升序指定“asc”。

论据

collection（Array | Object）：要迭代的集合。[iteratees=[_.identity]]（数组[]|函数[]|对象[]|字符串[]）：要排序的iterates。[orders]（string[]）：迭代的排序顺序。

退换商品

（Array）：返回新的排序数组。

var _ = require('lodash');
var homes = [
    {"h_id":"3",
     "city":"Dallas",
     "state":"TX",
     "zip":"75201",
     "price":"162500"},
    {"h_id":"4",
     "city":"Bevery Hills",
     "state":"CA",
     "zip":"90210",
     "price":"319250"},
    {"h_id":"6",
     "city":"Dallas",
     "state":"TX",
     "zip":"75000",
     "price":"556699"},
    {"h_id":"5",
     "city":"New York",
     "state":"NY",
     "zip":"00010",
     "price":"962500"}
    ];
    
_.orderBy(homes, ['city', 'state', 'zip'], ['asc', 'desc', 'asc']);

如果你有重复的姓氏，你可以按名字排序-

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