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

Question

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?

Answer 1

Ceci est un vieux 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"]
};
 

Answer 2

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.

Answer 3

Ont créé un simple dictionnaire 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";
        }
    }
}

Ci-dessus la mise en œuvre peut maintenant être utilisé pour simuler un dictionnaire comme:

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!"

C'est juste une simulation de base. Il peut être optimisée par la mise en œuvre d'un meilleur temps d'exécution de l'algorithme de travailler dans au moins O(nlogn) le temps de la complexité, voire moins. Comme de fusion/tri rapide sur les tableaux et puis certains B-recherche pour les recherches. Je N'ai pas essayer une recherche sur le mappage d'une fonction de hachage en JS.

Aussi, une Clé et une Valeur pour la JSdict obj peut être transformées en variables privées à être sournois.

Espérons que cette aide!

Answer 4

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 des dictionnaires Python. Voir: JSON.org

Answer 5

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

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

Si vous ne le saviez pas, l'AS3 dictionnaire vous permet d'utiliser tous les objets comme les clés, plutôt que de simplement les chaînes de caractères. Ils viennent dans très maniable une fois que vous avez trouvé un emploi pour eux.

Ce n'est pas aussi rapide qu'un objet natif, mais je n'en ai pas trouvé d'importants problèmes à 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