如何对多维数组中的多列数据进行排序？答案

【问题标题】：How to sort multiple columns data in Multi-Dimensional array?如何对多维数组中的多列数据进行排序？
【发布时间】：2019-06-18 06:00:32
【问题描述】：

我正在使用 JavaScript 代码，其中有一个如下所示的数组：

数组：

[
    ["2015-08-09", 1.2, 1.20, 2.1],
    ["2015-08-10", 1.2, 1.21, 2.11],
    ["2015-08-11", 1.2, 0.99, 2.20],
    ["2015-10-29", 1.2, 1.12, 2.22],
    ["2015-09-10", 1.21, 1.19, 2.00]
]

我需要的结果是：

[
    ["2015-08-09", 1.20, 1.20, 2.10],
    ["2015-08-10", 1.20, 1.21, 2.11],
    ["2015-08-11", 1.20, 0.99, 2.20],
    ["2015-10-29", 1.20, 1.12, 2.22],
    ["2015-09-10", 1.21, 1.19, 2.00]
]

由于数组是 3 维的，我想对 column 1 和 2 进行排序，因此首先在 1 列上应用升序，然后在 2 列上应用升序（升序/降序）。

【问题讨论】：

不是二维的吗？只是说'
不是二维数组，还有它的动态数组？
关于动态数组...如果您不向我们提供有关动态含义的更多信息以及示例，我们将无法为您提供帮助。
你更新原题后，输入数组和预期结果其实是一回事，你能不能改进一下或者给更多反馈给你现在真正需要的东西？

标签： javascript arrays columnsorting

【解决方案1】：

我也遇到了同样的问题，找到了一个对多维数组中的多列数据进行排序的好解决方案。

检查以下代码

(function() {
      function deepsort(){
    var i, order= arguments, L= order.length, tem;
    return a.sort(function(a, b){
        i= 0;
      
        while(i < L){
          
            tem= order[i++];
          var res = tem.split("_");
            var ao= a[res[0]] || 0, bo= b[res[0]] || 0;
            if(ao== bo) continue;
           
          if(res[1] == "ASC"){
            return ao > bo? 1: -1;
          }
          if(res[1] == "DESC"){
             return ao < bo? 1: -1;
          }
        }
        return 0;
    });
}

var a= [
    ["2015-08-09", 1.2, 1.20, 2.1],
    ["2015-08-10", 1.2, 1.21, 2.11],
    ["2015-08-11", 1.2, 0.99, 2.20],
    ["2015-10-29", 1.2, 1.12, 2.22],
    ["2015-09-10", 1.21, 1.19, 2.00]
];
document.write(deepsort(1+"_ASC",2+"_ASC"));
// for better result view check console log
console.log(deepsort(1+"_ASC",2+"_ASC"))
//console.log(a.deepsort(1))
    
    })();

【讨论】：

【解决方案2】：

只需通过获取每列的增量来链接所需的顺序。

var array = [["2015-08-09", 1.2, 1.2], ["2015-08-10", 1.2, 1.21], ["2015-08-11", 1.2, 0.99], ["2015-10-29", 1.2, 1.12], ["2015-09-10", 1.21, 1.19]];

array.sort((a, b) => a[1] - b[1] || a[2] - b[2]);

console.log(array.map(a => a.join('  ')));

【讨论】：

您理解column 1 and 2 确实是索引为 1 和 2 的列这一事实让我感到惊讶，呵呵。说话时使用基于 0 索引的系统的人并不多。
数组维度是动态的并且可以增加。所以目前看起来 2 维可以增加到 n 维。并且排序也将在多个列上增加。

【解决方案3】：

在这里，您有另一种方法，在排序比较函数上使用更像数学表达式，并且还按照您的预期格式化输出：

const input = [
    ["2015-08-09", 1.2, 1.20, 2.1],
    ["2015-08-10", 1.2, 1.21, 2.11],
    ["2015-08-11", 1.2, 0.99, 2.20],
    ["2015-10-29", 1.2, 1.12, 2.22],
    ["2015-09-10", 1.21, 1.19, 2.00]
];

// First, we use map() to clone the array so we don't change
// the original, and also to format the numbers as you expect.

let res = input.map(
  ([a, b, c, d]) => [a, b.toFixed(2), c.toFixed(2), d.toFixed(2)]
);

// Now we sort the new array using a more-like mathematical expression.

res.sort((x, y) =>
{
    let n = x[1] - y[1], m = x[2] - y[2];
    return n +  m * (n === 0);
});

console.log(res);

【讨论】：

【解决方案4】：

实际上你的数组是二维的。你可以像一维数组一样对它进行排序：

const data = [
  [ "2015-08-09", 1.2, 1.2], 
  [ "2015-08-10", 1.2, 1.21], 
  [ "2015-08-11", 1.2, 0.99],
  [ "2015-10-29",  1.2, 1.12] , 
  [ "2015-09-10",  1.21, 1.19]   
]

function sort(a, b) {
  const col1 = new Date(a[0]) - new Date(b[0]);
  if (col1 === 0) {
    return a[1] - b[1];
  }
  return col1;
}

console.log(data.sort(sort))

在上面的示例中，我们首先按内部数组中的第一个字段进行排序。如果值相等 - 然后我们比较内部数组的第二个字段。

【讨论】：

除了这不会返回 OP 所需的结果（即使我以相同的方式实现它）。