如何按列值排序二维数组

How to sort 2 dimensional array by column value?

本文关键字:二维数组 排序 何按列      更新时间:2023-09-26

有谁能帮我在JavaScript中排序二维数组吗?

数据格式如下:

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

排序后应该是这样的:

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

基本上,按第一列排序。

欢呼

就是这么简单:

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;
    }
}

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

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]
});

试试这个:

//WITH FIRST COLUMN
arr = arr.sort((a, b) => a[0] - b[0]);
//WITH SECOND COLUMN
arr = arr.sort((a, b) => a[1] - b[1]);

注意:原来的答案使用了大于(>)而不是减去(-),这是评论所说的不正确

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

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

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

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);

一行:

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)
}

如果您想基于第一列(其中包含数字值)进行排序,那么试试这个:

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

如果您想基于第二列(其中包含字符串值)进行排序,那么试试这个:

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

注:对于第二种情况,您需要比较它们的ASCII值。

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

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"]]"

我使用sort对数组进行排序

这是我的代码:

const sortArr = (arr) => {
    arr.sort((valA, valB) => valA[0] - valB[0])
    return arr
}
const arr = [
    [12, 'AAA'],
    [58, 'BBB'],
    [28, 'CCC'],
    [18, 'DDD']
]
console.log(sortArr(arr))

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

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 script。

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"],
                          ]"
*/
}
Solution vary depend on column value is numeric or string. 
To sort by first column if value is numeric,
array.sort( (a, b) => a[0] - b[0]);
To sort by second column if value is numeric,
array.sort( (a, b) => a[1] - b[1]);
To sort by first column if value is string/letter,
array.sort( function(a, b) {
    const nameA = a[0].toUpperCase(); // to avoid case while sort
    const nameB = b[0].toUpperCase();
    if(nameA > nameB)
        return 1;
    else if(nameB > nameA)
        return -1;
    else
        return 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;
    }
  }
}

好主意Sabbir 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)));

指定排序顺序和列的二维数组排序。默认顺序0表示没有变化,因此必须指定顺序:1 =>升序,-1 =>下行。默认列为0。

let sort2d = (arr2d = [], order = 0, column = 0) => {
    if (column < 0 || column > 1) {
        if (order == 1) 
            return arr2d.sort((a, b) => a[column] - b[column])
        if (order == -1) 
            return arr2d.sort((a, b) => b[column] - a[column])
    }
    return arr2d
}
let arr2d = [ [5, 3], [2, 5], [9, 1], [4, 1] ]
console.log(sort2d(arr2d, 1, -1)) //  [ [ 2, 5 ], [ 5, 3 ], [ 9, 1 ], [ 4, 1 ] ]

如果你想要一个多维整数数组排序的解决方案,其中子数组具有固定长度[[6 1 5],[8、3、5],[8、2,6],[8 3 6]]

const array = [ [ -6, 1, 5 ], [ -8, 3, 5 ], [ -8, 2, 6 ], [ -8, 3, 6 ] ]
const multiArraySort = (array, num) => {
  return array = array.sort((a,b) => {
    let boolean = true
    let i = 0 
    while(boolean){      
      if(a[i] === b[i]){        
        if(a[i+1] === b[i+1]){          
          i < num - 1 ? i++ : boolean = false
        }else {          
          return a[i+1] - b[i+1]          
        }        
      } else {                
        return a[i] - b[i]
      }
    }
    return 0
  })
}
// 3 represents the fixed length of sub-array
let sarray = multiArraySort(array, 3) //cant' assign in const array

回答:[[8、2,6],[8、3、5],[8 3 6],[6 1 5]]