Itérer sur un tableau associatif Javascript dans l'ordre trié

Disons que j'ai un tableau associatif Javascript (aka hash, aka dictionary):

var a = new Array();
a['b'] = 1;
a['z'] = 1;
a['a'] = 1;

Comment puis-je parcourir les clés dans un ordre trié? Si cela aide à simplifier les choses, je n'ai même pas besoin des valeurs (elles ne sont que le chiffre 1).

Vous ne pouvez pas les parcourir directement, mais vous pouvez trouver toutes les clés, puis les trier.

var a = new Array();
a['b'] = 1;
a['z'] = 1;
a['a'] = 1;    

function keys(obj)
{
    var keys = [];

    for(var key in obj)
    {
        if(obj.hasOwnProperty(key))
        {
            keys.push(key);
        }
    }

    return keys;
}

keys(a).sort(); // ["a", "b", "z"]

Cependant, il n'est pas nécessaire de faire de la variable «a» un tableau. Vous l'utilisez vraiment comme un objet et vous devriez le créer comme ceci:

var a = {};
a["key"] = "value";

Vous pouvez utiliser la méthode intégrée Object.keys :

var sorted_keys = Object.keys(a).sort()

(Remarque: cela ne fonctionne pas dans les très anciens navigateurs ne prenant pas en charge EcmaScript5, notamment IE6, 7 et 8. Pour des statistiques détaillées à jour, voir ce tableau )

vous pouvez même le prototyper sur un objet:

Object.prototype.iterateSorted = function(worker)
{
    var keys = [];
    for (var key in this)
    {
        if (this.hasOwnProperty(key))
            keys.push(key);
    }
    keys.sort();

    for (var i = 0; i < keys.length; i++)
    {
        worker(this[ keys[i] ]);
    }
}

et l'utilisation:

var myObj = { a:1, b:2 };
myObj.iterateSorted(function(value)
{
    alert(value);
} 

Je suis d'accord avec la réponse de Swingley , et je pense que c'est un point important que beaucoup de ces solutions plus élaborées manquent. Si vous n'êtes concerné que par les clés du tableau associatif et que toutes les valeurs sont «1», stockez simplement les «clés» en tant que valeurs dans un tableau.

Au lieu de:

var a = { b:1, z:1, a:1 };
// relatively elaborate code to retrieve the keys and sort them

Utilisation:

var a = [ 'b', 'z', 'a' ];
alert(a.sort());

Le seul inconvénient est que vous ne pouvez pas déterminer si une clé spécifique est définie aussi facilement. Voir cette réponse à la fonction javascript inArray pour une réponse à ce problème. Un problème avec la solution présentée est qu'elle a.hasValue('key')sera légèrement plus lente que a['key']. Cela peut ou non avoir une importance dans votre code.

Il n'y a pas de moyen concis de manipuler directement les "clés" d'un objet Javascript. Ce n'est pas vraiment conçu pour ça. Avez-vous la liberté de placer vos données dans quelque chose de mieux qu'un objet normal (ou un tableau, comme le suggère votre exemple de code)?

Si tel est le cas, et si votre question peut être reformulée comme suit: "Quel objet de type dictionnaire dois-je utiliser si je veux parcourir les clés dans un ordre trié?" alors vous pourriez développer un objet comme celui-ci:

var a = {
  keys : new Array(),
  hash : new Object(),
  set : function(key, value) {
    if (typeof(this.hash[key]) == "undefined") { this.keys.push(key); }
    this.hash[key] = value;
  },
  get : function(key) {
    return this.hash[key];
  },
  getSortedKeys : function() {
    this.keys.sort();
    return this.keys;
  }
};

// sample use
a.set('b',1);
a.set('z',1);
a.set('a',1);
var sortedKeys = a.getSortedKeys();
for (var i in sortedKeys) { print(sortedKeys[i]); }

Si vous n'avez aucun contrôle sur le fait que les données se trouvent dans un objet normal, cet utilitaire convertira l'objet régulier en votre dictionnaire entièrement fonctionnel:

a.importObject = function(object) {
  for (var i in object) { this.set(i, object); }
};

C'était une définition d'objet (au lieu d'une fonction de constructeur réutilisable) pour plus de simplicité; modifier à volonté.

Récupérez les clés dans la première forboucle, triez-la, utilisez le résultat trié dans la 2ème forboucle.

var a = new Array();
a['b'] = 1;
a['z'] = 1;
a['a'] = 1;

var b = [];
for (k in a) b.push(k);
b.sort();
for (var i = 0; i < b.length; ++i) alert(b[i]);

Vous pouvez utiliser la keysfonction de la bibliothèque underscore.js pour obtenir les clés, puis la sort()méthode array pour les trier:

var sortedKeys = _.keys(dict).sort();

La keysfonction dans le code source du trait de soulignement:

// Retrieve the names of an object's properties.
// Delegates to **ECMAScript 5**'s native `Object.keys`
_.keys = nativeKeys || function(obj) {
    if (obj !== Object(obj)) throw new TypeError('Invalid object');
    var keys = [];
    for (var key in obj) if (_.has(obj, key)) keys.push(key);
    return keys;
};    

// Shortcut function for checking if an object has a given property directly
// on itself (in other words, not on a prototype).
_.has = function(obj, key) {
    return hasOwnProperty.call(obj, key);
};

<script type="text/javascript">
    var a = {
        b:1,
        z:1,
        a:1
    }; // your JS Object
    var keys = [];
    for (key in a) {
        keys.push(key);
    }
    keys.sort();
    var i = 0;
    var keyslen = keys.length;
    var str = '';
    //SORTED KEY ITERATION
    while (i < keyslen) {
        str += keys[i] + '=>' + a[keys[i]] + '\n';
        ++i;
    }
    alert(str);
    /*RESULT:
    a=>1
    b=>1
    z=>1
    */
</script>

J'aime beaucoup l'idée de prototype de @ luke-schafer, mais j'entends aussi ce qu'il dit sur les problèmes avec les prototypes. Qu'en est-il d'utiliser une fonction simple?

function sortKeysAndDo( obj, worker ) {
  var keys = Object.keys(obj);
  keys.sort();
  for (var i = 0; i < keys.length; i++) {
     worker(keys[i], obj[keys[i]]);
  }
}

function show( key, value ) {
  document.write( key + ' : ' + value +'<br>' );
}

var a = new Array();
a['b'] = 1;
a['z'] = 1;
a['a'] = 1;

sortKeysAndDo( a, show);

var my_object = { 'c': 3, 'a': 1, 'b': 2 };

sortKeysAndDo( my_object, show);

Cela semble éliminer les problèmes avec les prototypes et fournir toujours un itérateur trié pour les objets. Cependant, je ne suis pas vraiment un gourou de JavaScript, alors j'aimerais savoir si cette solution contient des défauts cachés.