Gibt es Wörterbücher in Javascript wie Python?

Ich muss ein Wörterbuch in Javascript wie dieses machen

Ich erinnere mich nicht an die genaue Notation, aber es war so etwas wie:

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

Gibt es so etwas in Javascript?

Dies ist ein alter Beitrag, aber ich dachte, ich sollte trotzdem eine illustrierte Antwort geben.

Verwenden Sie die Objektnotation von Javascript. Wie so:

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

Und um auf die Werte zuzugreifen:

states_dictionary.AK[0] //which is liza

oder Sie können die Javascript-Literalobjektnotation verwenden, wobei die Schlüssel nicht in Anführungszeichen gesetzt werden müssen:

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

Bis 2015 (Veröffentlichung von ECMAScript 6) gab es in Javascript keine echten assoziativen Arrays. Seitdem können Sie das Map-Objekt als Robocat-Status verwenden. Schlagen Sie die Details in MDN nach . Beispiel:

let map = new Map();
map.set('key', {'value1', 'value2'});
let values = map.get('key');

Ohne Unterstützung für ES6 können Sie versuchen, Objekte zu verwenden:

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

Bei Objekten ist es jedoch nicht möglich, typische Array-Eigenschaften oder Methoden wie array.length zu verwenden. Zumindest ist es möglich, in einer for-in-Schleife auf das "Objekt-Array" zuzugreifen.

Mir ist klar, dass dies eine alte Frage ist, die jedoch in Google angezeigt wird, wenn Sie nach "Javascript-Wörterbüchern" suchen. Daher möchte ich zu den obigen Antworten hinzufügen, dass in ECMAScript 6 das offizielle MapObjekt eingeführt wurde, bei dem es sich um ein Wörterbuch handelt Implementierung:

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

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

Im Gegensatz zu den normalen Objekten von Javascript ist jedes Objekt als Schlüssel zulässig:

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({});

Habe hier ein einfaches Wörterbuch in JS erstellt:

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";
        }
    }
}

Die obige Implementierung kann nun verwendet werden, um ein Wörterbuch wie folgt zu simulieren:

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

Dies ist nur eine grundlegende Simulation. Es kann weiter optimiert werden, indem ein besserer Laufzeitalgorithmus implementiert wird, der in mindestens O (nlogn) Zeitkomplexität oder sogar weniger arbeitet. Wie Merge / Quick Sort auf Arrays und dann einige B-Suche nach Lookups. Ich habe nicht versucht oder nach dem Zuordnen einer Hash-Funktion in JS gesucht.

Außerdem können Schlüssel und Wert für das JSdict-Objekt in private Variablen umgewandelt werden, um hinterhältig zu sein.

Hoffe das hilft!

BEARBEITEN >> Nach der Implementierung des oben genannten habe ich die JS-Objekte persönlich als assoziative Arrays verwendet, die sofort verfügbar sind.

Aber ich würde gerne eine besondere Erwähnung über zwei Methoden machen , die tatsächlich hilfreich erwies es sich als eine bequeme hashtable Erlebnis zu machen.

Viz: dict.hasOwnProperty (Schlüssel) und lösche dict [Schlüssel]

Lesen Sie diesen Beitrag als gute Ressource für diese Implementierung / Verwendung. Dynamisches Erstellen von Schlüsseln im assoziativen JavaScript-Array

Vielen Dank!

Verwenden Sie JavaScript-Objekte. Sie können auf ihre Eigenschaften wie Schlüssel in einem Wörterbuch zugreifen. Dies ist die Grundlage von JSON. Die Syntax ähnelt Python-Wörterbüchern. Siehe: JSON.org

Eine alte Frage, aber ich musste kürzlich einen AS3> JS-Port erstellen. Aus Gründen der Geschwindigkeit habe ich ein einfaches Dictionary-Objekt im AS3-Stil für JS geschrieben:

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

Wenn Sie es nicht wussten, können Sie im AS3-Wörterbuch jedes Objekt als Schlüssel verwenden, anstatt nur Zeichenfolgen. Sie sind sehr praktisch, wenn Sie eine Verwendung für sie gefunden haben.

Es ist nicht so schnell wie ein natives Objekt, aber ich habe in dieser Hinsicht keine wesentlichen Probleme damit festgestellt.

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

Firefox 13+ bietet eine experimentelle Implementierung des mapObjekts ähnlich dem dictObjekt in Python. Technische Daten hier .

Es ist nur in Firefox verfügbar, sieht aber besser aus als die Verwendung von Attributen von a new Object(). Zitat aus der Dokumentation:

• Ein Objekt hat einen Prototyp, daher gibt es Standardschlüssel in der Karte. Dies kann jedoch mit umgangen werden map = Object.create(null).
• Die Schlüssel von a Objectsind Strings, wo sie einen beliebigen Wert für a haben können Map.
• Sie können die Größe eines Mapleicht ermitteln, während Sie die Größe für ein manuell verfolgen müssen Object.