Javascript中的排序列表

我有一个列表，其成员是嵌套的整数列表，例如：

[ [1,2], [], [1,2,3], [ [1,2],3], [1,2,4], [ [], [1,2] ], [34,5,6], [-1,66] ]

[] < [ [1] ] < [ [1,2] ] < [ [2] ] < [ [11] ]

<>我想对这个列表进行排序，使用（世界上所有其他语言）都会考虑嵌套列表的标准排序。例如：

[ [1,2], [], [1,2,3], [ [1,2],3], [1,2,4], [ [], [1,2] ], [34,5,6], [-1,66] ]

[] < [ [1] ] < [ [1,2] ] < [ [2] ] < [ [11] ]

[][[1]][[1,2]][[2]][[11]]

l.sort（）

会把这搞砸，因为它会把列表变成字符串

---

在javascript（或lodash这样的公共库）中，有没有一种简单的方法可以获得适当的嵌套列表排序？

您可以使用自定义排序函数，请参见此

例如：

var l = [[1,2], [], [34,5,6], [-1,66]];

l = l.sort(function (a, b) {

  if(!a.length) {
      return -1; 
  }

  if(!b.length) {
      return 1; 
  }

  return a[0] - b[0];
});

---

您可能需要处理更多的边缘情况，但这里有您的想法。

您可以使用自定义排序功能，请参见此

例如：

var l = [[1,2], [], [34,5,6], [-1,66]];

l = l.sort(function (a, b) {

  if(!a.length) {
      return -1; 
  }

  if(!b.length) {
      return 1; 
  }

  return a[0] - b[0];
});

---

你可能需要处理更多的边缘情况，但你有这个想法。

编辑：好的，受@Damien答案的启发，这是肮脏的，但会很好地工作。但愿我能做点更干净的事

您可能可以使用“压缩”每个相等值的数组。但是JSFIDLE没有最新版本的lodash，所以我无法测试它

var l = [[1,2],[],[1,3],[34, 5, 6],[-1, 66]];

l = l.sort(function(a, b) {

  var minLength = Math.min(a.length, b.length);

  for (var i = 0; i < minLength; i++) { // Compare the "matching pairs"
    if (a[i] < b[i]) {
      return -1;
    } else if(a[i] > b[i]){
        return 1;
    }
  }

  return a.length - b.length; // If all pairs were equals, use list length
});

var l=[[1,2]、[1,3]、[34,5,6]、-1,66]；
l=l.sort（函数（a，b）{
var minLength=Math.min（a.length，b.length）；
对于（var i=0；ib[i]）{
返回1；
}
}
返回a.length-b.length；//如果所有对都相等，则使用列表长度
});

---

编辑：好的，受@Damien答案的启发，这是肮脏的，但会很好地工作。但愿我能做点更干净的事

您可能可以使用“压缩”每个相等值的数组。但是JSFIDLE没有最新版本的lodash，所以我无法测试它

var l = [[1,2],[],[1,3],[34, 5, 6],[-1, 66]];

l = l.sort(function(a, b) {

  var minLength = Math.min(a.length, b.length);

  for (var i = 0; i < minLength; i++) { // Compare the "matching pairs"
    if (a[i] < b[i]) {
      return -1;
    } else if(a[i] > b[i]){
        return 1;
    }
  }

  return a.length - b.length; // If all pairs were equals, use list length
});

var l=[[1,2]、[1,3]、[34,5,6]、-1,66]；
l=l.sort（函数（a，b）{
var minLength=Math.min（a.length，b.length）；
对于（var i=0；ib[i]）{
返回1；
}
}
返回a.length-b.length；//如果所有对都相等，则使用列表长度
});

---

您可以使用uu.sortBy作为快捷方式

_.sortBy(arr, function (o) { return o[0] || Infinity } )

或者，如果您的内部阵列尚未排序：

_.sortBy(arr, function (o) { return someMutatedArr[0] || Infinity } )

编辑：

我找到了一种更好的方法，可以对列表中的第一项以外的内容进行排序，但空数组仍然位于末尾。我知道，你可以把它作为一个边缘案例单独处理，这很烦人

var arr = [ [11], [1,3], [2], [], [1], [1,2]]
var count = []

// Get an array that is as long as the longest array with [0, 1, 2, etc]
arr.forEach(function (e, i) { 
  if (e.length > (count.length) ) 
    count.push(count.length -1) 
})

_.sortBy(arr, count)

---

您可以使用u.sortBy作为快捷方式

_.sortBy(arr, function (o) { return o[0] || Infinity } )

或者，如果您的内部阵列尚未排序：

_.sortBy(arr, function (o) { return someMutatedArr[0] || Infinity } )

编辑：

我找到了一种更好的方法，可以对列表中的第一项以外的内容进行排序，但空数组仍然位于末尾。我知道，你可以把它作为一个边缘案例单独处理，这很烦人

var arr = [ [11], [1,3], [2], [], [1], [1,2]]
var count = []

// Get an array that is as long as the longest array with [0, 1, 2, etc]
arr.forEach(function (e, i) { 
  if (e.length > (count.length) ) 
    count.push(count.length -1) 
})

_.sortBy(arr, count)

为了

结果是

[ [], [ [ 1 ] ], [ [ 1, 2 ] ], [ [ 2 ] ], [ [ 11 ] ] ]

为了

结果是

[ [], [ [ 1 ] ], [ [ 1, 2 ] ], [ [ 2 ] ], [ [ 11 ] ] ]

---

这是一个由两个相互递归的函数组成的系统，第一个将数组与非数组进行比较，将数字与数字进行比较，第二个将数组与元素进行比较

函数cmp（x，y）{
设ax=Array.isArray（x），
ay=阵列。isArray（y）；
返回ax-ay | |（ax？cmpArr（x，y）：x-y）；
}
函数cmpArr（x，y）{
设xlen=x.长度，
ylen=y.长度，
最小=xlenconsole.log（JSON.stringify（a））

这是一个由两个相互递归的函数组成的系统，第一个函数比较数组和非数组，数字和数字，第二个函数比较数组的元素

函数cmp（x，y）{
设ax=Array.isArray（x），
ay=阵列。isArray（y）；
返回ax-ay | |（ax？cmpArr（x，y）：x-y）；
}
函数cmpArr（x，y）{
设xlen=x.长度，
ylen=y.长度，
最小=xlenconsole.log（JSON.stringify（a））

我在第2、3或4版中都没有看到lodash

\uu.sort（）

-具体使用哪个函数？2之前的11是因为数组内容可能是字符串，而不是数字。在比较器中使用

parseInt

，或者事先使用parseInt进行映射。lodash根本没有排序，我目前正在使用javascript排序。请查看。顺便说一句，其他任何语言都会对不均匀嵌套的列表感到厌烦。

[1,2,3,4]

是否会比

[1,2,3,4]

大甚至都不直观。你只是想把它们展平吗？预期的结果是什么？我在第2、3或4版中都没有看到lodash

\uu.sort（）

-你具体使用哪个函数？2之前的11是因为你的数组内容可能是字符串，而不是数字。在比较器中使用

parseInt

，或者事先使用parseInt进行映射。lodash根本没有排序，我目前正在使用javascript排序。请查看。顺便说一句，其他任何语言都会对不均匀嵌套的列表感到厌烦。

[1,2,3,4]

是否会比

[1,2,3,4]

大甚至都不直观。你只是想把它们弄平吗？预期的结果是什么？我的错。固定的。现在它使用每个数组的第一个数字。我的例子太简单了——我的列表可以有相同的第一个元素，例如我可以有[1,2,3,4]和[1,2,3,5]我的坏元素。固定的。它现在使用每个数组的第一个数。我的例子太简单了，我的列表可以有相同的第一个元素，例如，我可以有元素[1,2,3.4]和[1,2,3.5]。你不能只考虑内部数组的第一个元素，例如，考虑排序<代码> [[1,2,3.5]，[1,2,3.4] ] < /C>