web-dev-qa-db-fra.com

y a-t-il des dictionnaires en javascript comme python?

j'ai besoin de faire un dictionnaire en javascript comme ça

je ne me souviens pas de la notation exacte, mais c'était quelque chose comme:

states_dictionary={ CT=[alex,harry], AK=[liza,alex], TX=[fred, harry] ........ }

y a-t-il une telle chose en javascript?

javascriptpython
82
l--''''''---------''''''''''''

Ceci est un ancien post, mais je pensais que je devrais quand même fournir une réponse illustrée.

Utilisez la notation d'objet de javascript. Ainsi:

states_dictionary={ 
     "CT":["alex","harry"], 
     "AK":["liza","alex"], 
     "TX":["fred", "harry"]
};

Et pour accéder aux valeurs:

states_dictionary.AK[0] //which is liza

ou vous pouvez utiliser la notation d'objet littéral javascript, les clés n'ayant pas besoin d'être entre guillemets:

states_dictionary={ 
     CT:["alex","harry"], 
     AK:["liza","alex"], 
     TX:["fred", "harry"]
};
104
Chief

Il n'y a pas de véritables tableaux associatifs en Javascript. Vous pouvez essayer d'utiliser des objets:

var x = new Object();
x["Key"] = "Value";

Cependant, avec des objets, il n'est pas possible d'utiliser des propriétés de tableau typiques ou des méthodes telles que array.length. Au moins, il est possible d'accéder au "tableau d'objets" dans une boucle for-in-in.

45
Alex

J'ai créé un dictionnaire simple en JS ici:

function JSdict() {
    this.Keys = [];
    this.Values = [];
}

// Check if dictionary extensions aren't implemented yet.
// Returns value of a key
if (!JSdict.prototype.getVal) {
    JSdict.prototype.getVal = function (key) {
        if (key == null) {
            return "Key cannot be null";
        }
        for (var i = 0; i < this.Keys.length; i++) {
            if (this.Keys[i] == key) {
                return this.Values[i];
            }
        }
        return "Key not found!";
    }
}


// Check if dictionary extensions aren't implemented yet.
// Updates value of a key
if (!JSdict.prototype.update) {
    JSdict.prototype.update = function (key, val) {
        if (key == null || val == null) {
            return "Key or Value cannot be null";
        }
        // Verify dict integrity before each operation
        if (keysLength != valsLength) {
            return "Dictionary inconsistent. Keys length don't match values!";
        }
        var keysLength = this.Keys.length;
        var valsLength = this.Values.length;
        var flag = false;
        for (var i = 0; i < keysLength; i++) {
            if (this.Keys[i] == key) {
                this.Values[i] = val;
                flag = true;
                break;
            }
        }
        if (!flag) {
            return "Key does not exist";
        }
    }
}



// Check if dictionary extensions aren't implemented yet.
// Adds a unique key value pair
if (!JSdict.prototype.add) {
    JSdict.prototype.add = function (key, val) {
        // Allow only strings or numbers as keys
        if (typeof (key) == "number" || typeof (key) == "string") {
            if (key == null || val == null) {
                return "Key or Value cannot be null";
            }
            if (keysLength != valsLength) {
                return "Dictionary inconsistent. Keys length don't match values!";
            }
            var keysLength = this.Keys.length;
            var valsLength = this.Values.length;
            for (var i = 0; i < keysLength; i++) {
                if (this.Keys[i] == key) {
                    return "Duplicate keys not allowed!";
                }
            }
            this.Keys.Push(key);
            this.Values.Push(val);
        }
        else {
            return "Only number or string can be key!";
        }
    }
}

// Check if dictionary extensions aren't implemented yet.
// Removes a key value pair
if (!JSdict.prototype.remove) {
    JSdict.prototype.remove = function (key) {
        if (key == null) {
            return "Key cannot be null";
        }
        if (keysLength != valsLength) {
            return "Dictionary inconsistent. Keys length don't match values!";
        }
        var keysLength = this.Keys.length;
        var valsLength = this.Values.length;
        var flag = false;
        for (var i = 0; i < keysLength; i++) {
            if (this.Keys[i] == key) {
                this.Keys.shift(key);
                this.Values.shift(this.Values[i]);
                flag = true;
                break;
            }
        }
        if (!flag) {
            return "Key does not exist";
        }
    }
}

L’implémentation ci-dessus peut maintenant être utilisée pour simuler un dictionnaire en tant que:

var dict = new JSdict();

dict.add(1, "one")

dict.add(1, "one more")
"Duplicate keys not allowed!"

dict.getVal(1)
"one"

dict.update(1, "onne")

dict.getVal(1)
"onne"

dict.remove(1)

dict.getVal(1)
"Key not found!"

Ceci est juste une simulation de base. Il peut être optimisé davantage en implémentant un meilleur algorithme de temps d'exécution afin de fonctionner dans au moins O(nlogn) complexité du temps ou même moins. Comme une fusion/tri rapide sur des tableaux, puis une recherche de recherche de type B Je n'ai pas essayé ni cherché à cartographier une fonction de hachage dans JS.

En outre, la clé et la valeur de l'objet JSdict peuvent être transformées en variables privées pour être sournoises.

J'espère que cela t'aides!

EDITER >> Après avoir implémenté ce qui précède, j’ai personnellement utilisé les objets JS en tant que tableaux associatifs disponibles immédiatement.

Cependant, je voudrais faire une mention spéciale à propos de deux méthodes qui se sont révélées utiles pour en faire une expérience de hashtable pratique.

Viz: dict.hasOwnProperty (clé) et supprime dict [clé]

Lisez cet article comme une bonne ressource pour cette implémentation/utilisation. Création dynamique de clés dans un tableau associatif JavaScript

Merci!

9
Vaibhav

Je réalise que cette question est ancienne, mais elle apparaît dans Google lorsque vous recherchez des "dictionnaires javascript". J'aimerais donc ajouter aux réponses ci-dessus que, dans ECMAScript 6, l'objet officiel Map a été introduite, qui est une implémentation du dictionnaire:

var dict = new Map();
dict.set("foo", "bar");

//returns "bar"
dict.get("foo");

Contrairement aux objets normaux de javascript, il autorise n'importe quel objet comme clé:

var foo = {};
var bar = {};
var dict = new Map();
dict.set(foo, "Foo");
dict.set(bar, "Bar");

//returns "Bar"
dict.get(bar);

//returns "Foo"
dict.get(foo);

//returns undefined, as {} !== foo and {} !== bar
dict.get({});
9
CJStuart

Utilisez des objets JavaScript. Vous pouvez accéder à leurs propriétés comme des clés dans un dictionnaire. C'est la base de JSON. La syntaxe est similaire à celle utilisée pour les dictionnaires Python. Voir: JSON.org

4
Adam

Une vieille question, mais j'ai récemment eu besoin de faire un port AS3> JS, et par souci de rapidité, j'ai écrit un simple objet Dictionnaire de style AS3 pour JS:

http://jsfiddle.net/MickMalone1983/VEpFf/2/

Si vous ne le saviez pas, le dictionnaire AS3 vous permet d'utiliser n'importe quel objet comme clé, par opposition à de simples chaînes. Ils vous seront très utiles une fois que vous les aurez trouvés utiles.

Ce n'est pas aussi rapide qu'un objet natif, mais je n'ai trouvé aucun problème significatif à cet égard.

API:

//Constructor
var dict = new Dict(overwrite:Boolean);

//If overwrite, allows over-writing of duplicate keys,
//otherwise, will not add duplicate keys to dictionary.

dict.put(key, value);//Add a pair
dict.get(key);//Get value from key
dict.remove(key);//Remove pair by key
dict.clearAll(value);//Remove all pairs with this value
dict.iterate(function(key, value){//Send all pairs as arguments to this function:
    console.log(key+' is key for '+value);
});


dict.get(key);//Get value from key
3
MickMalone1983

Firefox 13+ fournit une implémentation expérimentale de l'objet map similaire à l'objet dict en python. Spécifications ici .

C'est seulement disponible dans firefox, mais ça a l'air mieux que d'utiliser les attributs d'un new Object(). Citation de la documentation:

  • Un objet a un prototype, il y a donc des clés par défaut dans la carte. Cependant, ceci peut être contourné en utilisant map = Object.create(null).
  • Les clés d'un Object sont Strings, où elles peuvent être n'importe quelle valeur pour un Map.
  • Vous pouvez facilement obtenir la taille d'un Map tout en gardant manuellement trace de la taille d'un Object.
1
mquandalle