Javascript naturel de tri de tableau/objet et de maintenir l'indice de l'association

J'ai un tableau d'éléments comme suit en Javascript:

var users = Array();

users[562] = 'testuser3';
users[16] = 'testuser6';
users[834] = 'testuser1';
users[823] = 'testuser4';
users[23] = 'testuser2';
users[917] = 'testuser5';

J'ai besoin de trier ce tableau pour obtenir le résultat suivant:

users[834] = 'testuser1';
users[23] = 'testuser2';
users[562] = 'testuser3';
users[823] = 'testuser4';
users[917] = 'testuser5';
users[16] = 'testuser6';

Remarquez comment il est triée en fonction de la valeur du tableau et la valeur de l'indice de l'association est maintenue après le tableau est trié (c'est essentiel). J'ai cherché une solution à ce, déjà essayé de le faire, mais a frappé un mur.

Par ailleurs, je suis conscient que ce n'est techniquement pas un tableau, puisque cela voudrait dire que les indices sont toujours itération de 0 à n, où n+1 est le comptage du nombre instance n. Vous avez toutefois la définir, l'exigence pour le projet est toujours le même. Aussi, si cela fait une différence, je ne suis PAS à l'aide de jquery.

InformationsquelleAutor user396404 | 2010-09-29

L'ordre des éléments d'un tableau est défini par l'indice. Donc, même si vous spécifiez les valeurs dans un ordre différent, les valeurs seront toujours stockées dans l'ordre de leurs indices et undefined index sont undefined:

> var arr = [];
> arr[2] = 2;
> arr[0] = 0;
> arr
[0, undefined, 2]

Maintenant, si vous voulez stocker la paire de l'index et la valeur, vous aurez besoin d'une autre structure de données, peut-être un tableau de tableau comme ceci:

var arr = [
    [562, 'testuser3'],
    [16, 'testuser6'],
    [834, 'testuser1'],
    [823, 'testuser4'],
    [23, 'testuser2'],
    [917, 'testuser5']
];

Cela peut être triée avec cette fonction de comparaison:

function cmp(a, b) {
    return a[1].localeCompare(b[1]);
}
arr.sort(cmp);

Le résultat est ce tableau:

[
    [834, 'testuser1'],
    [23, 'testuser2'],
    [562, 'testuser3'],
    [823, 'testuser4'],
    [917, 'testuser5'],
    [16, 'testuser6']
]

InformationsquelleAutor Gumbo

7

Si je comprends correctement à la question, vous êtes à l'aide de tableaux d'une manière qu'ils ne sont pas destinés à être utilisés. En fait, l'initialisation de style
```
//Don't do this!
var array = new Array();
array[0] = 'value';
array[1] = 'value';
array[2] = 'value';
```
enseigne mal de choses sur la nature et l'objet de tableaux. Un tableau est une liste ordonnée d'éléments, indexé à partir de zéro. La bonne façon de créer un tableau avec une littéral de tableau:
```
var array = [
    'value',
    'value',
    'value'
]
```
Les indices sont implicites dans l'ordre les éléments sont spécifiés. La création d'un tableau et de réglage users[562] = 'testuser3' implique qu'il y a au moins 562 autres utilisateurs dans la liste, et que vous avez une raison pour en connaissant seulement la 563rd en ce moment.

Dans votre cas, l'indice est données, et ne représente pas l'ordre des éléments dans le jeu. Ce que vous cherchez est une carte ou un dictionnaire, représenté en JavaScript par un objet ordinaire:
```
var users = {
    562: 'testuser3',
    16:  'testuser6',
    834: 'testuser1',
    823: 'testuser4',
    23:  'testuser2',
    917: 'testuser5'
}
```
Maintenant votre ne dispose pas d'un ordre, mais n'ont de sens clés. De là, vous pouvez suivre galambalazs conseils pour créer un tableau de l'objet clés:
```
var userOrder;
if (typeof Object.keys === 'function') {
    userOrder = Object.keys(users);
} else {
    for (var key in users) {
        userOrder.push(key);
    }
}
```
...puis de les trier:
```
userOrder.sort(function(a, b){
    return users[a].localeCompare(users[b]);
});
```
Voici une démo
- Je suis d'accord! D'où ma réponse diffèrent avec qui?
- Jamais l'esprit. Quelque part, je pensais que vous étiez en train de trier les propriétés d'un objet.
InformationsquelleAutor s4y

Vous ne pouvez pas commander des tableaux comme ça en Javascript. Votre meilleur pari est de faire un carte de commande.

order = new Array();
order[0] = 562;
order[1] = 16;
order[2] = 834;
order[3] = 823;
order[4] = 23;
order[5] = 917;

De cette façon, vous pouvez avoir n'importe quel ordre que vous voulez, indépendamment de l'clés dans le tableau d'origine.
Pour trier votre tableau à l'utilisation d'un personnalisé fonction de tri.

order.sort( function(a, b) {
  if ( users[a] < users[b] ) return -1;
  else if ( users[a] > users[b] ) return 1;
  else return 0;
});

for ( var i = 0; i < order.length; i++ ) {
  //users[ order[i] ]
}

[Démo]

InformationsquelleAutor gblazex

En utilisant les idées les commentaires, je suis venu avec la solution suivante. Le naturalSort fonction est quelque chose que j'ai trouvé sur google et je l'ai modifié pour trier un tableau multidimensionnel. En gros, j'ai fait les utilisateurs de tableau un tableau multidimensionnel avec le premier indice de l'id utilisateur et le deuxième indice étant le nom d'utilisateur. Donc:

users[0][0] = 72;
users[0][1] = 'testuser4';
users[1][0] = 91;
users[1][1] = 'testuser2';
users[2][0] = 12;
users[2][1] = 'testuser8';
users[3][0] = 3;
users[3][1] = 'testuser1';
users[4][0] = 18;
users[4][1] = 'testuser7';
users[5][0] = 47;
users[5][1] = 'testuser3';
users[6][0] = 16;
users[6][1] = 'testuser6';
users[7][0] = 20;
users[7][1] = 'testuser5';

J'ai ensuite trié le tableau pour obtenir la sortie suivante:

users_sorted[0][0] = 3;
users_sorted[0][1] = 'testuser1';
users_sorted[1][0] = 91;
users_sorted[1][1] = 'testuser2';
users_sorted[2][0] = 47;
users_sorted[2][1] = 'testuser3';
users_sorted[3][0] = 72;
users_sorted[3][1] = 'testuser4';
users_sorted[4][0] = 20;
users_sorted[4][1] = 'testuser5';
users_sorted[5][0] = 16;
users_sorted[5][1] = 'testuser6';
users_sorted[6][0] = 18;
users_sorted[6][1] = 'testuser7';
users_sorted[7][0] = 12;
users_sorted[7][1] = 'testuser8';

Le code pour faire cela est ci-dessous:

function naturalSort(a, b) //Function to natural-case insensitive sort multidimensional arrays by second index
{
//setup temp-scope variables for comparison evauluation
var re = /(-?[0-9\.]+)/g,
x = a[1].toString().toLowerCase() || '',
y = b[1].toString().toLowerCase() || '',
nC = String.fromCharCode(0),
xN = x.replace( re, nC + '$1' + nC ).split(nC),
yN = y.replace( re, nC + '$1' + nC ).split(nC),
xD = (new Date(x)).getTime(),
yD = xD ? (new Date(y)).getTime() : null;
//natural sorting of dates
if ( yD )
if ( xD < yD ) return -1;
else if ( xD > yD ) return 1;
//natural sorting through split numeric strings and default strings
for( var cLoc = 0, numS = Math.max(xN.length, yN.length); cLoc < numS; cLoc++ ) {
oFxNcL = parseFloat(xN[cLoc]) || xN[cLoc];
oFyNcL = parseFloat(yN[cLoc]) || yN[cLoc];
if (oFxNcL < oFyNcL) return -1;
else if (oFxNcL > oFyNcL) return 1;
}
return 0;
}
//Set values for index
var users = Array();
var temp = Array();
users.push(Array('72', 'testuser4'));
users.push(Array('91', 'testuser2'));
users.push(Array('12', 'testuser8'));
users.push(Array('3', 'testuser1'));
users.push(Array('18', 'testuser7'));
users.push(Array('47', 'testuser3'));
users.push(Array('16', 'testuser6'));
users.push(Array('20', 'testuser5'));
//Sort the array
var users_sorted = Array();
users_sorted = users.sort(naturalSort);

Hey, je suis content que vous avez trouvé une réponse qui fonctionne, mais je vous encourage à jeter un rapide coup d'oeil à ma réponse (j'ai été un peu en retard pour le jeu!) ci-dessus. Comparaison de chaîne est construite en JavaScript, et vous trouverez peut-être une solution plus propre dans l'ensemble.
Vous pouvez aussi rechercher dans un tableau et l'objet des littéraux (je mentionne brièvement dans ma réponse). Vous pouvez créer que users tableau dans votre exemple de code beaucoup plus rapide: var users = [['72', 'testuser4'], ['91', 'testuser2'], …]
Merci pour le heads up, il n'a pas l'air plus propre. Prend-il en charge naturel en cas de tri si? C'est ce que fait mon code un peu bâclé.
Il effectue "paramètres régionaux sensible à la comparaison de chaînes de caractères", ce qui vous obtient plus de la façon dont il. Si vous en avez besoin pour être sensible à la casse, rendre les chaînes de caractères en minuscules avant d'appeler localeCompare: ['Foo', 'foo', 'aardvark', 'Baardvark'].sort(function(a, b){ return a.toLowerCase().localeCompare(b.toLowerCase()) }) -> ["aardvark", "Baardvark", "Foo", "foo"]

InformationsquelleAutor user396404

J'avais utilisation de la carte une fois pour faire un nouveau groupe d'utilisateurs,
puis une seconde fois pour revenir à la chaîne que vous voulez à partir de la nouvelle matrice.

var users= [];
users[562]= 'testuser3';
users[16]= 'testuser6';
users[834]= 'testuser1';
users[823]= 'testuser4';
users[23]= 'testuser2';
users[917]= 'testuser5';
var u2= [];
users.map(function(itm, i){
if(itm){
var n= parseInt(itm.substring(8), 10);
u2[n]= i;
}
});
u2.map(function(itm, i){
return 'users['+itm+']= testuser'+i;
}).join('\n');
/*returned value: (String)
users[834]= testuser1
users[23]= testuser2
users[562]= testuser3
users[823]= testuser4
users[917]= testuser5
users[16]= testuser6
*/

Si vous voulez éviter les lacunes. utiliser un simple filtre sur la sortie-

u2.map(function(itm, i){
return 'users['+itm+']= testuser'+i;
}).filter(function(itm){return itm}).join('\n');

InformationsquelleAutor kennebec

1

Matrices creuses généralement source de difficultés. Vous êtes mieux de sauver des paires clé-valeur dans un tableau comme des objets (cette technique est aussi valable JSON):
```
users = [{
"562": "testuser3"
},{
"16": "testuser6"
}, {
"834": "testuser1"
}, {
"823": "testuser4"
}, {
"23": "testuser2"
}, {
"917": "testuser5"
}];
```
Comme l'a suggéré, vous pouvez utiliser une boucle for pour mapper la fonction de tri sur le tableau.

InformationsquelleAutor AutoSponge
0

Array.le prototype.sort() prend une option personnalisée fonction de comparaison -- donc, si vous dump l'ensemble de vos users dans un tableau de cette manière [ [562, "testuser3"], [16, "testuser6"] ... etc.]

Puis sort ce tableau avec la fonction suivante:
```
function(comparatorA, comparatorB) {
var userA = comparatorA[1], userB = comparatorB[1]
if (userA > userB)     return 1;
if (userA < userB)     return -1;
if (userA === userB)   return 0;
}
```
Puis reconstruire votre users objet. (Qui va perdre des vous votre le tri). Ou, conserver les données dans le nouveau tableau trié de tableaux, si cela fonctionnera pour votre application.

InformationsquelleAutor Sean Vieira

Vous devez vous connecter pour publier un commentaire.