Comment trier un tableau multi dimensionnel par plusieurs colonnes en JavaScript?

Le littéral de tableau [] est préféré au new Array. La notation {0,4,3,1} n'est pas valide et doit être [0,4,3,1].

Est-il nécessaire de réinventer la roue? Deux tableaux peut être joint à l'aide de:

originalArray = originalArray.concat(addArray);

Éléments peuvent être ajoutés à la fin de l'aide:

array.push(element);

Tableaux ont une méthode pour trier le tableau. Par défaut, c'est par ordre numérique:

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

Les tableaux peuvent être inversés. En poursuivant l'exemple précédent:

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

De fournir un tri personnalisé, vous pouvez passer l'option argument de fonction à 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"]
*/

Éléments conservent leur position si l'élément est égal à un autre élément. En utilisant cela, vous pouvez combiner plusieurs de tri algoritms. Vous devez appliquer vos préférences de tri dans l'ordre inverse depuis le dernier tri a la priorité sur les précédents. Pour trier le tableau ci-dessous par la première colonne (par ordre décroissant), puis la deuxième colonne (par ordre croissant):

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]
*/

Pour trier latine cordes (c'est à dire l'anglais, l'allemand, le néerlandais), l'utilisation String.localeCompare:

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

Pour trier date de la Date objet, utiliser leurs millisecondes représentation:

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

Vous pouvez appliquer cette fonction de tri à tous les types de données, il suffit de suivre les règles:

x est le résultat de la comparaison entre deux valeurs qui doivent être renvoyées par une fonction transmise à array.sort.

1. x < 0: element_a devrait venir avant element_b
2. x = 0: element_a et element_b sont égaux, les éléments ne sont pas échangés
3. x > 0: element_a devrait venir après element_b

OriginalL'auteur Lekensteyn

Basé sur Lekensteyn est une excellente réponse, j'ai développé la solution suivante pour mes besoins. Je n'ai pas fait le plein les contrôles de qualité sur encore et de la ne sais pas si c'est parfait (en fait, je suis assez sûr qu'il ne l'est pas), mais j'espère que d'autres personnes peuvent obtenir de l'utilisation de ce et de s'en inspirer pour leurs besoins. Je vais poster une mise à jour si des changements majeurs nécessaires faite.

function do2DArraySort(dataArr, orderList, orderDir) {
for (x=orderList.length-1; x >= 0; x--) {
if (orderDir[x] == 'asc') {
dataArr.sort(sortMethodFunctionAsc);
} else {
dataArr.sort(sortMethodFunctionDesc);
}
}
return dataArr;
}
function sortMethodFunctionAsc(a, b) {
if ((IsNumeric(a[orderList[x]]) && IsNumeric(b[orderList[x]])) || (IsDate(a[orderList[x]]) && IsDate(b[orderList[x]]))) {
return a[orderList[x]] - b[orderList[x]];
} else {
if (a[orderList[x]].toString() > b[orderList[x]].toString()) {
return 1;
} else if (a[orderList[x]].toString() < b[orderList[x]].toString()) {
return -1;
} else {
return 0;
}
}
}
function sortMethodFunctionDesc(a, b) {
if ((IsNumeric(a[orderList[x]]) && IsNumeric(b[orderList[x]])) || (IsDate(a[orderList[x]]) && IsDate(b[orderList[x]]))) {
return b[orderList[x]] - a[orderList[x]];
} else {
if (a[orderList[x]].toString() < b[orderList[x]].toString()) {
return 1;
} else if (a[orderList[x]].toString() > b[orderList[x]].toString()) {
return -1;
} else {
return 0;
}
}
}
function IsNumeric(input) {
return (input - 0) == input && input.length > 0;
}
function IsDate(testValue) {
var returnValue = false;
var testDate;
try {
testDate = new Date(testValue);
if (!isNaN(testDate)) {
returnValue = true;
} else {
returnValue = false;
}
}
catch (e) {
returnValue = false;
}
return returnValue;
}

OriginalL'auteur Nicholas