sortBy 说它是一种稳定的排序算法，因此您应该能够先按第二个属性排序，然后再按第一个属性排序，如下所示：

var sortedArray = _(patients).chain().sortBy(function(patient) {
    return patient[0].name;
}).sortBy(function(patient) {
    return patient[0].roomNumber;
}).value();

当第二个sortBy发现 John 和 Lisa 具有相同的房间号时，它将按照找到它们的顺序保留他们，第一个sortBy设置为“Lisa，John”。

这是我有时在这些情况下使用的一个技巧：以结果可排序的方式组合属性：

var sortedArray = _.sortBy(patients, function(patient) {
  return [patient[0].roomNumber, patient[0].name].join("_");
});

然而，正如我所说，这很hacky。要正确执行此操作，您可能希望实际使用核心 JavaScriptsort方法：

patients.sort(function(x, y) {
  var roomX = x[0].roomNumber;
  var roomY = y[0].roomNumber;
  if (roomX !== roomY) {
    return compare(roomX, roomY);
  }
  return compare(x[0].name, y[0].name);
});

// General comparison function for convenience
function compare(x, y) {
  if (x === y) {
    return 0;
  }
  return x > y ? 1 : -1;
}

当然，这会将您的数组排序到位。如果你想要一个排序的副本（就像_.sortBy会给你的），首先克隆数组：

function sortOutOfPlace(sequence, sorter) {
  var copy = _.clone(sequence);
  copy.sort(sorter);
  return copy;
}

出于无聊，我也为此编写了一个通用解决方案（按任意数量的键排序）：看看.

我知道我迟到了，但我想为那些需要更清洁、更快速的解决方案的人添加这个，这些解决方案已经建议了。您可以按照最不重要的属性到最重要的属性的顺序链接 sortBy 调用。在下面的代码创建的排序患者一个新的数组名称中RoomNumber从原来的阵列称为患者。

var sortedPatients = _.chain(patients)
  .sortBy('Name')
  .sortBy('RoomNumber')
  .value();

顺便说一句，您的患者初始化程序有点奇怪，不是吗？为什么不将这个变量初始化为这个 - 作为一个真正的对象数组- 你可以使用_.flatten()而不是作为单个对象的数组数组来完成，也许这是错字问题）：

var patients = [
        {name: 'Omar', roomNumber: 3, bedNumber: 1},
        {name: 'John', roomNumber: 1, bedNumber: 1},
        {name: 'Chris', roomNumber: 2, bedNumber: 1},
        {name: 'Lisa', roomNumber: 1, bedNumber: 2},
        {name: 'Kiko', roomNumber: 1, bedNumber: 2}
        ];

我对清单进行了不同的排序，并将 Kiko 添加到 Lisa 的床上；只是为了好玩，看看会发生什么变化......

var sorted = _(patients).sortBy( 
                    function(patient){
                       return [patient.roomNumber, patient.bedNumber, patient.name];
                    });

检查排序，你会看到这个

[
{bedNumber: 1, name: "John", roomNumber: 1}, 
{bedNumber: 2, name: "Kiko", roomNumber: 1}, 
{bedNumber: 2, name: "Lisa", roomNumber: 1}, 
{bedNumber: 1, name: "Chris", roomNumber: 2}, 
{bedNumber: 1, name: "Omar", roomNumber: 3}
]

所以我的答案是：在你的回调函数中使用一个数组， 这与Dan Tao的答案非常相似，我只是忘记了 join（可能是因为我删除了唯一项的数组数组 :)）
使用你的数据结构，然后它将是 ：

var sorted = _(patients).chain()
                        .flatten()
                        .sortBy( function(patient){
                              return [patient.roomNumber, 
                                     patient.bedNumber, 
                                     patient.name];
                        })
                        .value();

测试负载会很有趣......

这些答案都不是在排序中使用多个字段的通用方法的理想选择。上述所有方法都是低效的，因为它们要么需要对数组进行多次排序（这在足够大的列表上可能会减慢很多速度），要么会生成大量的垃圾对象，VM 需要清理这些对象（并最终减慢速度）程序关闭）。

这是一个快速、高效、轻松允许反向排序的解决方案，可以与underscore或一起使用lodash，或直接与Array.sort

最重要的部分是compositeComparator方法，它接受一组比较器函数并返回一个新的复合比较器函数。

/**
 * Chains a comparator function to another comparator
 * and returns the result of the first comparator, unless
 * the first comparator returns 0, in which case the
 * result of the second comparator is used.
 */
function makeChainedComparator(first, next) {
  return function(a, b) {
    var result = first(a, b);
    if (result !== 0) return result;
    return next(a, b);
  }
}

/**
 * Given an array of comparators, returns a new comparator with
 * descending priority such that
 * the next comparator will only be used if the precending on returned
 * 0 (ie, found the two objects to be equal)
 *
 * Allows multiple sorts to be used simply. For example,
 * sort by column a, then sort by column b, then sort by column c
 */
function compositeComparator(comparators) {
  return comparators.reduceRight(function(memo, comparator) {
    return makeChainedComparator(comparator, memo);
  });
}

您还需要一个比较器函数来比较您希望排序的字段。该naturalSort函数将创建一个给定特定字段的比较器。为反向排序编写一个比较器也很简单。

function naturalSort(field) {
  return function(a, b) {
    var c1 = a[field];
    var c2 = b[field];
    if (c1 > c2) return 1;
    if (c1 < c2) return -1;
    return 0;
  }
}

（到目前为止，所有代码都是可重用的，例如可以保存在实用程序module中）

接下来，您需要创建复合比较器。对于我们的示例，它看起来像这样：

var cmp = compositeComparator([naturalSort('roomNumber'), naturalSort('name')]);

这将按房间号排序，然后是名称。添加额外的排序条件是微不足道的，不会影响排序的性能。

var patients = [
 {name: 'John', roomNumber: 3, bedNumber: 1},
 {name: 'Omar', roomNumber: 2, bedNumber: 1},
 {name: 'Lisa', roomNumber: 2, bedNumber: 2},
 {name: 'Chris', roomNumber: 1, bedNumber: 1},
];

// Sort using the composite
patients.sort(cmp);

console.log(patients);

返回以下内容

[ { name: 'Chris', roomNumber: 1, bedNumber: 1 },
  { name: 'Lisa', roomNumber: 2, bedNumber: 2 },
  { name: 'Omar', roomNumber: 2, bedNumber: 1 },
  { name: 'John', roomNumber: 3, bedNumber: 1 } ]

我更喜欢这种方法的原因是它允许对任意数量的字段进行快速排序，不会产生大量垃圾或在排序中执行字符串连接，并且可以轻松使用，以便某些列反向排序，而顺序列使用自然种类。