javascript - 如何在 JavaScript 中按多列对多维数组进行排序？

Question

我整天都在研究这个问题，没有一个好的解决方案。谷歌也没有什么帮助。我有一个脚本需要接受一个行/列数未知的二维数组。该脚本还需要接受一个一维数组，其中包含要排序的列列表，以及另一个包含要排序的顺序的数组。调用看起来有点像这样:

var orderList = {0,4,3,1};
var orderDir = {asc,desc,desc,asc};
dataArr = do2DArraySort(dataArr, orderList, orderDir);

函数 do2DArraySort 应该返回按第一列(升序)、第五列(降序)、第三列(降序)、第二列(降序)排序的 dataArr 数组).我可以使用下面的代码将它加深两层，但是一旦我尝试添加第三个排序列，它就会崩溃。我明白为什么，但我想不出一个好的方法让它发挥作用。

有没有标准的方法来做到这一点？有人可以给我指出一个好的在线脚本，我可以学习并用作模板吗？或者有人可以建议修改我的代码以使其正常工作吗？

谢谢!

//appends an array content to the original array
function addToArray(originalArray, addArray) {
    if (addArray.length != 0) {
        var curLength = 0;
        curLength = originalArray.length;
        var maxLength = 0;
        maxLength = curLength + addArray.length;  
        var itrerateArray = 0;
        for (var r = curLength; r < maxLength; r++) {   
            originalArray[r] = addArray[itrerateArray];
            itrerateArray++;
        }
    }
}

function do2DArraySort(arrayToBeSorted, sortColumnArray, sortDirectionArray) {
    if (arrayToBeSorted == "undefined" || arrayToBeSorted == "null") return arrayToBeSorted;
    if (arrayToBeSorted.length == 0) return arrayToBeSorted;
    if (sortColumnArray.length == 0) return arrayToBeSorted;
    tempArray = arrayToBeSorted; 
    var totalLength = sortColumnArray.length; 
    for(var m = 0; m < totalLength; m++) {
        if (m == 0) {   
            doBubbleSort(tempArray, tempArray.length, sortColumnArray[m], sortDirectionArray[m]);         
        } else {     
            doMultipleSort(tempArray, sortColumnArray[m], sortColumnArray[m-1], sortDirectionArray[m]);
        }
    } 
    return tempArray;
}

//check if a value exists in a single dimensional array
function checkIfExists(arrayToSearch, valueToSearch) {
    if (arrayToSearch == "undefined" || arrayToSearch == "null") return false;
    if (arrayToSearch.length == 0) return false;
    for (var k = 0; k < arrayToSearch.length; k++) {
        if (arrayToSearch[k] == valueToSearch) return true;
    }
    return false;
}

//sorts an 2D array based on the distinct values of the previous column
function doMultipleSort(sortedArray, currentCol, prevCol, sortDirection) {
    var resultArray = new Array(); 
    var newdistinctValuesArray = new Array();
    //finding distinct previous column values 
    for (var n = 0; n < sortedArray.length; n++) {
        if (checkIfExists(newdistinctValuesArray, sortedArray[n][prevCol]) == false) newdistinctValuesArray.push(sortedArray[n][prevCol]);
    }
    var recCursor = 0;
    var newTempArray = new Array(); var toStoreArray = 0; 
    //for each of the distinct values
    for (var x = 0; x < newdistinctValuesArray.length; x++) {
        toStoreArray = 0;
        newTempArray = new Array();  
        //find the rows with the same previous column value
        for (var y = 0; y < sortedArray.length; y++) {
            if (sortedArray[y][prevCol] == newdistinctValuesArray[x]) {
                newTempArray[toStoreArray] = sortedArray[y];
                toStoreArray++;
            }
        }       //sort the row based on the current column
        doBubbleSort(newTempArray, newTempArray.length, currentCol, sortDirection);
        //append it to the result array
        addToArray(resultArray, newTempArray);
    }
    tempArray = resultArray;
}

Answer 1

数组文字 []优先于 new Array .符号{0,4,3,1}无效，应为 [0,4,3,1] .

是否需要重新发明轮子？可以使用以下方式连接两个数组:

originalArray = originalArray.concat(addArray);

可以使用以下方式将元素附加到末尾:

array.push(element);

数组有一个排序数组的方法。默认情况下，它按数字排序:

// sort elements numerically
var array = [1, 3, 2];
array.sort(); // array becomes [1, 2, 3]

数组也可以反转。继续前面的例子:

array = array.reverse(); //yields [3, 2, 1]

要提供自定义排序，您可以将可选的函数参数传递给 array.sort() :

array = [];
array[0] = [1, "first element"];
array[1] = [3, "second element"];
array[2] = [2, "third element"];
array.sort(function (element_a, element_b) {
    return element_a[0] - element_b[0];
});
/** array becomes (in order):
 * [1, "first element"]
 * [2, "third element"]
 * [3, "second element"]
 */

如果元素等于另一个元素，元素将保持其位置。使用它，您可以组合多个排序算法。您必须以相反的顺序应用您的排序首选项，因为最后的排序优先于之前的排序。按第一列(降序)然后第二列(升序)对以下数组进行排序:

array = [];
array.push([1, 2, 4]);
array.push([1, 3, 3]);
array.push([2, 1, 3]);
array.push([1, 2, 3]);
// sort on second column
array.sort(function (element_a, element_b) {
    return element_a[1] - element_b[1];
});
// sort on first column, reverse sort
array.sort(function (element_a, element_b) {
    return element_b[0] - element_a[0];
});
/** result (note, 3rd column is not sorted, so the order of row 2+3 is preserved)
 * [2, 1, 3]
 * [1, 2, 4] (row 2)
 * [1, 2, 3] (row 3)
 * [1, 3, 3]
 */

要对拉丁字符串(即英语、德语、荷兰语)进行排序，请使用 String.localeCompare :

array.sort(function (element_a, element_b) {
    return element_a.localeCompare(element_b);
});

对 Date 中的日期进行排序对象，使用它们的毫秒表示:

array.sort(function (element_a, element_b) {
    return element_a.getTime() - element_b.getTime();
});

您可以将此排序功能应用于所有类型的数据，只需遵循以下规则:

x是比较两个值的结果，这两个值应该由传递给 array.sort 的函数返回.

1. x < 0 : element_a应该在 element_b 之前
2. x = 0 : element_a和 element_b相等，元素不交换
3. x > 0 : element_a应该在element_b之后