Comment trier un tableau associatif par ses valeurs en Javascript?

Au lieu de corriger vous sur la sémantique d'un tableau associatif", je pense que c'est ce que vous voulez:

function getSortedKeys(obj) {
    var keys = keys = Object.keys(obj);
    return keys.sort(function(a,b){return obj[b]-obj[a]});
}

pour vraiment vieux navigateurs, utilisez ceci à la place:

function getSortedKeys(obj) {
    var keys = []; for(var key in obj) keys.push(key);
    return keys.sort(function(a,b){return obj[b]-obj[a]});
}

Vous dump dans un objet (comme le vôtre) et d'obtenir un tableau de clés - eh propriétés - retour, triés en ordre décroissant par le (numérique) valeur de l', hein, les valeurs de l', hein, de l'objet.

Cela ne fonctionne que si vos valeurs sont numériques. Ajustez le petit function(a,b) là pour changer le mécanisme de tri pour le travail croissant, ou travailler pour string valeurs (par exemple). Laissé comme exercice pour le lecteur.

Il n'y a vraiment aucune une telle chose comme un "tableau associatif" en JavaScript. Ce que vous avez, il y a une plaine de l'ancien objet. Ils travaillent genre de comme des tableaux associatifs, bien sûr, et les clés sont disponibles mais il n'y a pas de sémantique autour de la commande de touches.

Vous pourriez faire de votre objet dans un tableau d'objets (des paires clé/valeur) et de sorte que:

function sortObj(object, sortFunc) {
  var rv = [];
  for (var k in object) {
    if (object.hasOwnProperty(k)) rv.push({key: k, value:  object[k]});
  }
  rv.sort(function(o1, o2) {
    return sortFunc(o1.key, o2.key);
  });
  return rv;
}

Alors vous feriez appel à un comparateur de fonction.

Aucune complication inutile requis...

function sortMapByValue(map)
{
    var tupleArray = [];
    for (var key in map) tupleArray.push([key, map[key]]);
    tupleArray.sort(function (a, b) { return a[1] - b[1] });
    return tupleArray;
}

La meilleure approche pour le cas spécifique ici, à mon avis, est l'un commonpike suggéré. Un peu d'amélioration, je vous suggère de qui fonctionne dans les navigateurs modernes est:

//aao is the "associative array" you need to "sort"
Object.keys(aao).sort(function(a,b){return aao[b]-aao[a]});

Cela pourrait s'appliquer facilement et de l'excellent travail dans le cas spécifique ici, de sorte que vous pouvez faire:

let aoo={};
aao["sub2"]=1;
aao["sub0"]=-1;
aao["sub1"]=0;
aao["sub3"]=1;
aao["sub4"]=0;

let sk=Object.keys(aao).sort(function(a,b){return aao[b]-aao[a]});

//now you can loop using the sorted keys in `sk` to do stuffs
for (let i=sk.length-1;i>=0;--i){
 //do something with sk[i] or aoo[sk[i]]
}

En plus de cela, j'ai ici une de plus "générique" de la fonction que vous pouvez utiliser pour trier, même dans le plus large éventail de situations et qui se mélange à l'amélioration j'ai juste suggéré avec les approches de réponses en Ben Vide (également le tri des valeurs de chaîne) et PopeJohnPaulII (tri par champ d'objet/propriété) et à vous de décider si vous voulez un ascendant ou descendant de l'ordre, c'est ici:

//aao := is the "associative array" you need to "sort"
//comp := is the "field" you want to compare or "" if you have no "fields" and simply need to compare values
//intVal := must be false if you need comparing non-integer values
//desc := set to true will sort keys in descendant order (default sort order is ascendant)
function sortedKeys(aao,comp="",intVal=false,desc=false){
let keys=Object.keys(aao);
if (comp!="") {
if (intVal) {
if (desc) return keys.sort(function(a,b){return aao[b][comp]-aao[a][comp]});
else return keys.sort(function(a,b){return aao[a][comp]-aao[a][comp]});
} else {
if (desc) return keys.sort(function(a,b){return aao[b][comp]<aao[a][comp]?1:aao[b][comp]>aao[a][comp]?-1:0});
else return keys.sort(function(a,b){return aao[a][comp]<aao[b][comp]?1:aao[a][comp]>aao[b][comp]?-1:0});
}
} else {
if (intVal) {
if (desc) return keys.sort(function(a,b){return aao[b]-aao[a]});
else return keys.sort(function(a,b){return aao[a]-aao[b]});
} else {
if (desc) return keys.sort(function(a,b){return aao[b]<aao[a]?1:aao[b]>aao[a]?-1:0});
else return keys.sort(function(a,b){return aao[a]<aao[b]?1:aao[a]>aao[b]?-1:0});
}
}
}

Vous pouvez tester les fonctionnalités d'essayer quelque chose comme le code suivant:

let items={};
items['Edward']=21;
items['Sharpe']=37;
items['And']=45;
items['The']=-12;
items['Magnetic']=13;
items['Zeros']=37;
//equivalent to:
//let items={"Edward": 21, "Sharpe": 37, "And": 45, "The": -12, ...};
console.log("1: "+sortedKeys(items));
console.log("2: "+sortedKeys(items,"",false,true));
console.log("3: "+sortedKeys(items,"",true,false));
console.log("4: "+sortedKeys(items,"",true,true));
/* OUTPUT
1: And,Sharpe,Zeros,Edward,Magnetic,The
2: The,Magnetic,Edward,Sharpe,Zeros,And
3: The,Magnetic,Edward,Sharpe,Zeros,And
4: And,Sharpe,Zeros,Edward,Magnetic,The
*/
items={};
items['k1']={name:'Edward',value:21};
items['k2']={name:'Sharpe',value:37};
items['k3']={name:'And',value:45};
items['k4']={name:'The',value:-12};
items['k5']={name:'Magnetic',value:13};
items['k6']={name:'Zeros',value:37};
console.log("1: "+sortedKeys(items,"name"));
console.log("2: "+sortedKeys(items,"name",false,true));
/* OUTPUT
1: k6,k4,k2,k5,k1,k3
2: k3,k1,k5,k2,k4,k6
*/

Comme je l'ai déjà dit, vous pouvez passer en boucle triés clés si vous avez besoin de faire le fourre

let sk=sortedKeys(aoo);
//now you can loop using the sorted keys in `sk` to do stuffs
for (let i=sk.length-1;i>=0;--i){
//do something with sk[i] or aoo[sk[i]]
}

Dernier, mais non le moins, quelques références utiles pour Objet.touches et Tableau.tri

@commonpike la réponse est "la bonne", mais comme il se passe de commentaire...

la plupart des navigateurs de nos jours, en plus de soutenir Object.keys()

Ouais.. Object.keys() est mieux.

Mais ce qui est encore mieux? Bah, c'est dans coffeescript!

sortedKeys = (x) -> Object.keys(x).sort (a,b) -> x[a] - x[b]
sortedKeys
'a' :  1
'b' :  3
'c' :  4
'd' : -1

[ 'd', 'a', 'b', 'c' ]