104

任何人都可以帮我在 JavaScript 中对二维数组进行排序吗？

它将具有以下格式的数据：

[12, AAA]
[58, BBB]
[28, CCC]
[18, DDD]

排序后应该是这样的：

[12, AAA]
[18, DDD]
[28, CCC]
[58, BBB]

所以基本上，按第一列排序。

干杯

4

11 回答 11

132

就是这么简单：

var a = [[12, 'AAA'], [58, 'BBB'], [28, 'CCC'],[18, 'DDD']];

a.sort(sortFunction);

function sortFunction(a, b) {
    if (a[0] === b[0]) {
        return 0;
    }
    else {
        return (a[0] < b[0]) ? -1 : 1;
    }
}

我邀请您阅读文档。

如果要按第二列排序，可以这样做：

a.sort(compareSecondColumn);

function compareSecondColumn(a, b) {
    if (a[1] === b[1]) {
        return 0;
    }
    else {
        return (a[1] < b[1]) ? -1 : 1;
    }
}
于 2013-04-19T04:11:13.287 回答
74

最好的方法是使用以下方法，因为第一列中可能存在重复值。

var arr = [[12, 'AAA'], [12, 'BBB'], [12, 'CCC'],[28, 'DDD'], [18, 'CCC'],[12, 'DDD'],[18, 'CCC'],[28, 'DDD'],[28, 'DDD'],[58, 'BBB'],[68, 'BBB'],[78, 'BBB']];

arr.sort(function(a,b) {
    return a[0]-b[0]
});
于 2014-01-21T22:33:45.233 回答
57

尝试这个

//WITH FIRST COLUMN
arr = arr.sort(function(a,b) {
    return a[0] - b[0];
});


//WITH SECOND COLUMN
arr = arr.sort(function(a,b) {
    return a[1] - b[1];
});

注意：原始答案使用大于（>）而不是减号（-），这就是评论所指的不正确。

于 2013-04-19T03:47:58.147 回答
13

使用箭头函数，并按第二个字符串字段排序

var a = [[12, 'CCC'], [58, 'AAA'], [57, 'DDD'], [28, 'CCC'],[18, 'BBB']];
a.sort((a, b) => a[1].localeCompare(b[1]));
console.log(a)

于 2017-05-18T14:48:02.753 回答
11

如果您像我一样，您不会希望每次更改排序依据的列时都更改每个索引。

function sortByColumn(a, colIndex){

    a.sort(sortFunction);

    function sortFunction(a, b) {
        if (a[colIndex] === b[colIndex]) {
            return 0;
        }
        else {
            return (a[colIndex] < b[colIndex]) ? -1 : 1;
        }
    }

    return a;
}

var sorted_a = sortByColumn(a, 2);
于 2014-05-30T16:51:52.117 回答
6

在一行中：

var cars = [
  {type:"Volvo", year:2016},
  {type:"Saab", year:2001},
  {type:"BMW", year:2010}
]


function myFunction() {
  return cars.sort((a, b)=> a.year - b.year)
}
于 2020-03-21T13:53:15.620 回答
5

如果要根据第一列（包含数值）进行排序，请尝试以下操作：

arr.sort(function(a,b){
  return a[0]-b[0]
})

如果要根据第二列（包含字符串值）进行排序，请尝试以下操作：

arr.sort(function(a,b){
  return a[1].charCodeAt(0)-b[1].charCodeAt(0)
})

PS 对于第二种情况，您需要比较它们的 ASCII 值。

于 2020-07-01T15:25:12.540 回答
3

没什么特别的，只是节省了从数组中返回某个索引处的值所需的成本。

function sortByCol(arr, colIndex){
    arr.sort(sortFunction)
    function sortFunction(a, b) {
        a = a[colIndex]
        b = b[colIndex]
        return (a === b) ? 0 : (a < b) ? -1 : 1
    }
}
// Usage
var a = [[12, 'AAA'], [58, 'BBB'], [28, 'CCC'],[18, 'DDD']]
sortByCol(a, 0)
console.log(JSON.stringify(a))
// "[[12,"AAA"],[18,"DDD"],[28,"CCC"],[58,"BBB"]]"
于 2016-11-02T20:32:25.103 回答
1

站在 charles-clayton 和@vikas-gautam 的肩膀上，我添加了字符串测试，如果列具有 OP 中的字符串则需要该测试。

return isNaN(a-b) ? (a === b) ? 0 : (a < b) ? -1 : 1 : a-b  ;

测试isNaN(a-b)确定字符串是否不能强制转换为数字。如果他们可以，那么a-b测试是有效的。

请注意，对混合类型的列进行排序总是会产生有趣的结果，因为严格相等测试(a === b)总是会返回 false。 在此处查看 MDN

这是带有 Logger 测试的完整脚本 - 使用 Google Apps 脚本。

function testSort(){

function sortByCol(arr, colIndex){
    arr.sort(sortFunction);
    function sortFunction(a, b) {
        a = a[colIndex];
        b = b[colIndex];
       return isNaN(a-b) ? (a === b) ? 0 : (a < b) ? -1 : 1 : a-b  ;  // test if text string - ie cannot be coerced to numbers.
       // Note that sorting a column of mixed types will always give an entertaining result as the strict equality test will always return false
       // see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness

       }
}
// Usage
var a = [ [12,'12', 'AAA'],
          [12,'11', 'AAB'],
          [58,'120', 'CCC'],
          [28,'08', 'BBB'],
          [18,'80', 'DDD'],
        ]
    var arr1 = a.map(function (i){return i;}).sort();  // use map to ensure tests are not corrupted by a sort in-place.

    Logger.log("Original unsorted:\n     " + JSON.stringify(a));
    Logger.log("Vanilla sort:\n     " + JSON.stringify(arr1));
    sortByCol(a, 0);
    Logger.log("By col 0:\n     " + JSON.stringify(a));
    sortByCol(a, 1);
    Logger.log("By col 1:\n     " + JSON.stringify(a));
    sortByCol(a, 2);
    Logger.log("By col 2:\n     " + JSON.stringify(a));

/* vanilla sort returns " [
                            [12,"11","AAB"],
                            [12,"12","AAA"],
                            [18,"80","DDD"],
                            [28,"08","BBB"],
                            [58,"120","CCC"]
                          ]
   if col 0 then returns "[
                            [12,'12',"AAA"],
                            [12,'11', 'AAB'],
                            [18,'80',"DDD"],
                            [28,'08',"BBB"],
                            [58,'120',"CCC"]
                          ]"
   if col 1 then returns "[
                            [28,'08',"BBB"],
                            [12,'11', 'AAB'],
                            [12,'12',"AAA"],
                            [18,'80',"DDD"],
                            [58,'120',"CCC"],

                          ]"
   if col 2 then returns "[
                            [12,'12',"AAA"],
                            [12,'11', 'AAB'],
                            [28,'08',"BBB"],
                            [58,'120',"CCC"],
                            [18,'80',"DDD"],
                          ]"
*/

}
于 2019-07-04T17:43:43.677 回答
0

由于我的用例涉及几十个列，我稍微扩展了@jahroy 的答案。（也刚刚意识到@charles-clayton 也有同样的想法。）
我传递了我想要排序的参数，并使用所需的索引重新定义了排序函数，以便进行比较。

var ID_COLUMN=0
var URL_COLUMN=1

findings.sort(compareByColumnIndex(URL_COLUMN))

function compareByColumnIndex(index) {
  return function(a,b){
    if (a[index] === b[index]) {
        return 0;
    }
    else {
        return (a[index] < b[index]) ? -1 : 1;
    }
  }
}
于 2017-04-05T21:22:19.170 回答
0

好主意 Sabir Ahmed，但只按第一个字符排序，三个：

array.sort((a, b) => (a[n].charCodeAt(0)*1000000 + a[n].charCodeAt(1)*1000 + a[n].charCodeAt(2)) - (b[n].charCodeAt(0)*1000000 + b[n].charCodeAt(1)*1000 + b[n].charCodeAt(2)));
于 2021-06-05T14:27:54.977 回答