Javascript'te Python gibi sözlükler var mı?

Javascript'te böyle bir sözlük oluşturmam gerekiyor

Tam olarak notasyonu hatırlamıyorum, ama şöyle bir şeydi:

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

Javascript'te böyle bir şey var mı?

Cevap #1

Bu eski bir gönderi, ama yine de resimli bir cevap vermem gerektiğini düşündüm.

Javascript'in nesne gösterimini kullanın. Şöyle:

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

Ve değerlere erişmek için:

states_dictionary.AK[0] //which is liza

veya anahtarların tırnak içinde olmasına gerek olmayan JavaScript literal nesne notasyonunu kullanabilirsiniz:

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

Cevap #2

Javascript'te 2015 yılına kadar (ECMAScript 6 yayınlanana kadar) gerçek ilişkilendirici diziler yoktu. O zamandan beri, Robocat'ın belirttiği gibi Map nesnesini kullanabilirsiniz. Ayrıntılar için MDN'e bakın. Örnek:

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

ES6 desteği olmadan nesneleri kullanmayı deneyebilirsiniz:

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

Ancak nesnelerle tipik dizi özelliklerini veya metodlarını, örneğin array.length, kullanmak mümkün değildir. En azından "nesne-dizi"ye for-in döngüsünde erişmek mümkündür.

Cevap #3

ECMAScript 6'da, bir sözlük uygulaması olan resmi Map nesnesi tanıtıldı:

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

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

Javascript'in normal nesnelerinin aksine, kimlik karşılaştırması kullanarak herhangi bir nesneyi anahtar olarak kullanmasına izin verir:

let foo = {};
let bar = {};
let 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({});

Kullanıcı tanımlı bir anahtar karşılaştırıcısı kullanmanın bir yolu yok, bu yüzden kimlik karşılaştırması istemiyorsanız, normal bir nesne ile olduğu gibi sadece sayı veya string anahtarlarını kullanmakla sınırlısınız.

Cevap #4

JS'te burada basit bir sözlük oluşturdum:

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

Yukarıdaki uygulama artık bir sözlüğü simüle etmek için şöyle kullanılabilir:

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

Bu sadece temel bir simülasyon. En az O(nlogn) zaman karmaşıklığında veya daha az çalışacak daha iyi bir çalışma zamanı algoritması uygulayarak daha da optimize edilebilir. Diziler üzerinde merge/quick sort ve ardından aramalar için bazı ikili aramalar gibi. JS'de bir hash fonksiyonunu eşlemeyi denemedim veya araştırmadım.

Ayrıca, JSdict objesi için Anahtar ve Değer gizlice olmak için özel değişkenlere dönüştürülebilir.

Umarım bu yardımcı olur!

DÜZENLE >> Yukarıdakileri uyguladıktan sonra, ben şahsen JS nesnelerini kutudan çıktığı gibi kullanılabilir ilişkisel diziler olarak kullandım.

Ancak, aslında kullanımı kolay bir hash tablosu deneyimi sağlamakta yardımcı olduğu kanıtlanmış iki yönteme özel olarak değinmek istiyorum.

Bakınız: dict.hasOwnProperty(key) ve delete dict[key]

Bu gönderiyi bu uygulama/kullanım hakkında iyi bir kaynak olarak okuyun. JavaScript ilişkisel dizisinde anahtarları dinamik olarak oluşturma

Teşekkürler!

İlgili makaleler