（见jsfiddle）

var data = [
    { count: '12', year: '1956' },
    { count: '1', year: '1971' },
    { count: '33', year: '1989' },
    { count: '33', year: '1988' }
];

console.log(data.sort(function (x, y) {
    var n = x.count - y.count;
    if (n !== 0) {
        return n;
    }

    return x.year - y.year;
}));

一个简单的解决方案是：

data.sort(function (a, b) {
  return a.count - b.count || a.year - b.year;
});

这是有效的，因为如果计数不同，则排序基于此。如果count相同，则第一个表达式返回 0 并转换为false并使用第二个表达式的结果（即排序基于year）。

你可以使用 JavaScript 的.sort()数组方法（试试看）：

data.sort(function(a, b) {
    // Sort by count
    var dCount = a.count - b.count;
    if(dCount) return dCount;

    // If there is a tie, sort by year
    var dYear = a.year - b.year;
    return dYear;
});

注意：这会更改原始数组。如果您需要先制作副本，您可以这样做：

var dataCopy = data.slice(0);

基于伟大的@RobG解决方案，这是一个通用函数，用于按多个不同的属性排序，使用 JS2015 棘手map + find：

let sortBy = (p, a) => a.sort((i, j) => p.map(v => i[v] - j[v]).find(r => r))

sortBy(['count', 'year'], data)

此外，如果您愿意，也可以使用传统的 JS 版本（由于在旧浏览器中具有兼容性，请谨慎使用）：

var sortBy = function (properties, targetArray) {
  targetArray.sort(function (i, j) {
    return properties.map(function (prop) {
      return i[prop] - j[prop];
    }).find(function (result) {
      return result;
    });
  });
};

你必须像这样解决这个问题

var customSort = function(name, type){
     return function(o, p){
         var a, b;
         if(o && p && typeof o === 'object' && typeof p === 'object'){
            a = o[name];
            b = p[name];
           if(a === b){
              return typeof type === 'function' ? type(o, p) : o;
           }

           if(typeof a=== typeof b){
              return a < b ? -1 : 1;
            }
          return typeof a < typeof b ? -1 : 1;
        }
     };

};

例如： data.sort(customSort('year', customSort('count')));