javascript'te python gibi sözlükler var mı?

bunun gibi javascript'te bir sözlük yapmam gerekiyor

tam gösterimi 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ı?

Bu eski bir gönderi, ancak 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 javascript değişmez nesne gösterimini kullanabilirsiniz, burada anahtarların tırnak içinde olması gerekmez:

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

Javascript'te 2015 yılına kadar gerçek ilişkilendirilebilir dizi yoktu (ECMAScript 6 sürümü). O zamandan beri Harita nesnesini Robocat durumları olarak kullanabilirsiniz. Ayrıntıları MDN'de arayın . Misal:

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

Bununla birlikte, nesnelerle, tipik dizi özelliklerini veya dizi.length gibi yöntemleri kullanmak mümkün değildir. En azından bir döngü içinde "nesne dizisine" erişmek mümkündür.

Bunun eski bir soru olduğunun farkındayım, ancak 'javascript sözlüklerini' aradığınızda Google'da beliriyor, bu yüzden yukarıdaki yanıtlara ECMAScript 6'da resmi Mapnesnenin tanıtıldığı, yani bir sözlük olduğunu eklemek istiyorum. uygulama:

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

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

JavaScript'in normal nesnelerinin aksine, herhangi bir nesneye anahtar olarak izin verir:

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

JS'de basit bir sözlük oluşturduk:

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üğü şu şekilde simüle etmek için 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 basit bir simülasyon. En az O (nlogn) zaman karmaşıklığında veya hatta daha azında çalışmak için daha iyi bir çalışma süresi algoritması uygulayarak daha da optimize edilebilir. Dizilerde birleştirme / hızlı sıralama ve ardından aramalar için bazı B-arama gibi. JS'de bir hash işlevinin eşleştirilmesi hakkında bir deneme yapmadım veya arama yapmadım.

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

Bu yardımcı olur umarım!

DÜZENLE >> Yukarıdakileri uyguladıktan sonra, JS nesnelerini kişisel olarak kullanıma hazır olan ilişkilendirilebilir diziler olarak kullandım.

Bununla birlikte , kullanışlı bir hashtable deneyimi haline getirmek için gerçekten yararlı olduğu kanıtlanmış iki yöntemden özel olarak bahsetmek istiyorum.

Viz: dict.hasOwnProperty (anahtar) ve dict [anahtar] 'ı silin

Bu yazıyı, bu uygulama / kullanım hakkında iyi bir kaynak olarak okuyun. JavaScript ilişkilendirilebilir dizisinde dinamik olarak anahtarlar oluşturma

Teşekkürler!

JavaScript nesnelerini kullanın. Bir sözlükteki anahtarlar gibi özelliklerine erişebilirsiniz. JSON'un temeli budur. Sözdizimi Python sözlüklerine benzer. Bkz: JSON.org

Eski bir soru ama son zamanlarda bir AS3> JS bağlantı noktası yapmam gerekiyordu ve hız uğruna JS için basit bir AS3 tarzı Sözlük nesnesi yazdım:

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

Bilmiyorsanız, AS3 sözlüğü yalnızca dizelerin aksine herhangi bir nesneyi anahtar olarak kullanmanıza izin verir. Onlar için bir kullanım bulduğunuzda çok kullanışlı oluyorlar.

Yerli bir nesnenin olabileceği kadar hızlı değil, ancak bu bakımdan onunla önemli bir sorun bulamadım.

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+ mapnesnenin python'daki nesneye benzer deneysel bir uygulamasını sağlar dict. Özellikler burada .

Yalnızca firefox'ta kullanılabilir, ancak bir new Object(). Belgelerden alıntı:

• Bir Nesnenin bir prototipi vardır, bu nedenle haritada varsayılan anahtarlar vardır. Ancak bu, kullanılarak atlanabilir map = Object.create(null).
• Bir anahtarları Objectvardır Stringsonlar için herhangi bir değer olabilir nerede, Map.
• MapKolayca bir boyutu elde edebilirken , bir Object.