Ben C # yapmak gibi bir şekilde JavaScript kullanarak bazı istatistikleri depolamak gerekir:

Dictionary<string, int> statistics;

statistics["Foo"] = 10;
statistics["Goo"] = statistics["Goo"] + 1;
statistics.Add("Zoo", 1);

JavaScript'te Hashtableveya benzeri bir şey var mı Dictionary<TKey, TValue>?
Değerleri nasıl bu şekilde depolayabilirim?

Kullanım JavaScript ilişkisel diziler gibi nesneler .

İlişkilendirilebilir Dizi: Basit bir deyişle, ilişkilendirilebilir diziler dizin olarak Tamsayı sayıları yerine Dizeler kullanır.

İle nesne oluşturma

var dictionary = {};

Javascript, aşağıdaki sözdizimini kullanarak nesnelere özellik eklemenizi sağlar:

Object.yourProperty = value;

Bunun için alternatif bir sözdizimi:

Object["yourProperty"] = value;

Aşağıdaki sözdizimiyle nesne eşlemelerine değer vermek için anahtar da oluşturabilirseniz

var point = { x:3, y:2 };

point["x"] // returns 3
point.y // returns 2

Aşağıdaki gibi for..in döngü yapısını kullanarak ilişkilendirilebilir bir dizi üzerinden yineleme yapabilirsiniz

for(var key in Object.keys(dict)){
  var value = dict[key];
  /* use key/value for intended purpose */
}

var associativeArray = {};
associativeArray["one"] = "First";
associativeArray["two"] = "Second";
associativeArray["three"] = "Third";

Nesneye yönelik bir dilden geliyorsanız, bu makaleyi kontrol etmelisiniz .

Tüm modern tarayıcılar bir javascript Harita nesnesini destekler . Bir haritayı Nesne'den daha iyi hale getirmenin birkaç nedeni vardır:

• Bir Nesnenin bir prototipi vardır, dolayısıyla haritada varsayılan anahtarlar vardır.
• Bir Nesnenin anahtarları, bir Harita için herhangi bir değer olabileceği Dizelerdir.
• Bir Nesnenin boyutunu takip etmek zorundayken Harita boyutunu kolayca elde edebilirsiniz.

Misal:

var myMap = new Map();

var keyObj = {},
    keyFunc = function () {},
    keyString = "a string";

myMap.set(keyString, "value associated with 'a string'");
myMap.set(keyObj, "value associated with keyObj");
myMap.set(keyFunc, "value associated with keyFunc");

myMap.size; // 3

myMap.get(keyString);    // "value associated with 'a string'"
myMap.get(keyObj);       // "value associated with keyObj"
myMap.get(keyFunc);      // "value associated with keyFunc"

Başka nesnelerden referans alınmayan anahtarların çöp toplanmasını istiyorsanız , Harita yerine WeakMap kullanmayı düşünün .

Yapmamak için özel bir nedeniniz yoksa, normal bir nesne kullanın. Javascript'teki nesne özelliklerine hashtable tarzı sözdizimi kullanılarak başvurulabilir:

var hashtable = {};
hashtable.foo = "bar";
hashtable['bar'] = "foo";

Hem foove barelementler artık o kadar başvurulabilir:

hashtable['foo'];
hashtable['bar'];
// or
hashtable.foo;
hashtable.bar;

Tabii ki bu, anahtarlarınızın dize olması gerektiği anlamına gelir. Dizeler değilse, dahili olarak dizelere dönüştürülürler, bu yüzden yine de işe yarayabilir, YMMV.

JS'deki her nesne bir hashtable gibi davranıyor ve genellikle uygulandığından, sadece bununla devam ediyorum ...

var hashSweetHashTable = {};

C # 'da kod şöyle görünür:

Dictionary<string,int> dictionary = new Dictionary<string,int>();
dictionary.add("sample1", 1);
dictionary.add("sample2", 2);

veya

var dictionary = new Dictionary<string, int> {
    {"sample1", 1},
    {"sample2", 2}
};

JavaScript'te

var dictionary = {
    "sample1": 1,
    "sample2": 2
}

C # Sözlük nesne gibi yararlı yöntemler içerir dictionary.ContainsKey() JavaScript yarar bir hasOwnPropertybenzeri

if (dictionary.hasOwnProperty("sample1"))
    console.log("sample1 key found and its value is"+ dictionary["sample1"]);

Anahtarlarınızın sadece dizelerden ziyade herhangi bir nesne olmasını istiyorsanız, jshashtable'ımı kullanabilirsiniz .

function HashTable() {
    this.length = 0;
    this.items = new Array();
    for (var i = 0; i < arguments.length; i += 2) {
        if (typeof (arguments[i + 1]) != 'undefined') {
            this.items[arguments[i]] = arguments[i + 1];
            this.length++;
        }
    }

    this.removeItem = function (in_key) {
        var tmp_previous;
        if (typeof (this.items[in_key]) != 'undefined') {
            this.length--;
            var tmp_previous = this.items[in_key];
            delete this.items[in_key];
        }

        return tmp_previous;
    }

    this.getItem = function (in_key) {
        return this.items[in_key];
    }

    this.setItem = function (in_key, in_value) {
        var tmp_previous;
        if (typeof (in_value) != 'undefined') {
            if (typeof (this.items[in_key]) == 'undefined') {
                this.length++;
            } else {
                tmp_previous = this.items[in_key];
            }

            this.items[in_key] = in_value;
        }

        return tmp_previous;
    }

    this.hasItem = function (in_key) {
        return typeof (this.items[in_key]) != 'undefined';
    }

    this.clear = function () {
        for (var i in this.items) {
            delete this.items[i];
        }

        this.length = 0;
    }
}

Bunu nesne anahtarı eşlemesi, numaralandırma ( forEach()yöntemle) ve temizleme gibi bazı problemleri başarmak için yarattım .

function Hashtable() {
    this._map = new Map();
    this._indexes = new Map();
    this._keys = [];
    this._values = [];
    this.put = function(key, value) {
        var newKey = !this.containsKey(key);
        this._map.set(key, value);
        if (newKey) {
            this._indexes.set(key, this.length);
            this._keys.push(key);
            this._values.push(value);
        }
    };
    this.remove = function(key) {
        if (!this.containsKey(key))
            return;
        this._map.delete(key);
        var index = this._indexes.get(key);
        this._indexes.delete(key);
        this._keys.splice(index, 1);
        this._values.splice(index, 1);
    };
    this.indexOfKey = function(key) {
        return this._indexes.get(key);
    };
    this.indexOfValue = function(value) {
        return this._values.indexOf(value) != -1;
    };
    this.get = function(key) {
        return this._map.get(key);
    };
    this.entryAt = function(index) {
        var item = {};
        Object.defineProperty(item, "key", {
            value: this.keys[index],
            writable: false
        });
        Object.defineProperty(item, "value", {
            value: this.values[index],
            writable: false
        });
        return item;
    };
    this.clear = function() {
        var length = this.length;
        for (var i = 0; i < length; i++) {
            var key = this.keys[i];
            this._map.delete(key);
            this._indexes.delete(key);
        }
        this._keys.splice(0, length);
    };
    this.containsKey = function(key) {
        return this._map.has(key);
    };
    this.containsValue = function(value) {
        return this._values.indexOf(value) != -1;
    };
    this.forEach = function(iterator) {
        for (var i = 0; i < this.length; i++)
            iterator(this.keys[i], this.values[i], i);
    };
    Object.defineProperty(this, "length", {
        get: function() {
            return this._keys.length;
        }
    });
    Object.defineProperty(this, "keys", {
        get: function() {
            return this._keys;
        }
    });
    Object.defineProperty(this, "values", {
        get: function() {
            return this._values;
        }
    });
    Object.defineProperty(this, "entries", {
        get: function() {
            var entries = new Array(this.length);
            for (var i = 0; i < entries.length; i++)
                entries[i] = this.entryAt(i);
            return entries;
        }
    });
}

Sınıf belgeleri Hashtable

Yöntem:

• get(key)
  Belirtilen tuşla ilişkilendirilmiş değeri döndürür.
  Parametreler::
  key Değerin alındığı anahtar.

• put(key, value)
  Belirtilen değeri belirtilen anahtarla ilişkilendirir.
  Parametreler::
  key Değeri ilişkilendiren anahtar.
  value: Anahtarla ilişkilendirilecek değer.

• remove(key)
  Belirtilen anahtarı değeriyle kaldırır.
  Parametreler:: Kaldırılacak
  key anahtar.

• clear()
  Hem anahtarları hem de değerleri kaldırarak tüm hashtable'ı temizler.

• indexOfKey(key)
  Ekleme sırasına göre belirtilen anahtarın dizinini döndürür.
  Parametreler::
  key Dizini alan anahtar.

• indexOfValue(value)
  Ekleme sırasına göre belirtilen değerin dizinini döndürür.
  Parametreler::
  value Dizini alan değeri.
  Notlar:
  Bu bilgiler indexOf()bir dizinin yöntemi ile alınır , bu nedenle nesneyi yalnızca toString()yöntemle karşılaştırır .

• entryAt(index)
  İki özelliğe sahip bir nesne döndürür: belirtilen dizindeki girdiyi temsil eden anahtar ve değer.
  Parametreler::
  index Alınacak girdinin dizini.

• containsKey(key)
  Hashtable'ın belirtilen anahtarı içerip içermediğini döndürür.
  Parametreler::
  key Kontrol edilecek anahtar.

• containsValue(value)
  Hashtable'ın belirtilen değeri içerip içermediğini döndürür.
  Parametreler::
  value Kontrol edilecek değer.

• forEach(iterator)
  Belirtilen tüm girdileri yineler iterator.
  Parametreler:
  value :: 3 parametrelerle bir yöntem key, valueve index, indexgirişin dizinini temsil eder.

  Özellikleri:

• length ( Salt okunur )
  Hashhtable içindeki girişlerin sayısını alır.

• keys ( Salt okunur )
  Hashhtable içindeki tüm anahtarların bir dizisini alır.

• values ( Salt okunur )
  Hashhtable içindeki tüm değerlerin bir dizisini alır.

• entries ( Salt okunur )
  Hashhtable içindeki tüm girdilerin bir dizisini alır. Yöntemin aynı formunda temsil edilirler entryAt().

https://gist.github.com/alexhawkins/f6329420f40e5cafa0a4

var HashTable = function() {
  this._storage = [];
  this._count = 0;
  this._limit = 8;
}


HashTable.prototype.insert = function(key, value) {
  //create an index for our storage location by passing it through our hashing function
  var index = this.hashFunc(key, this._limit);
  //retrieve the bucket at this particular index in our storage, if one exists
  //[[ [k,v], [k,v], [k,v] ] , [ [k,v], [k,v] ]  [ [k,v] ] ]
  var bucket = this._storage[index]
    //does a bucket exist or do we get undefined when trying to retrieve said index?
  if (!bucket) {
    //create the bucket
    var bucket = [];
    //insert the bucket into our hashTable
    this._storage[index] = bucket;
  }

  var override = false;
  //now iterate through our bucket to see if there are any conflicting
  //key value pairs within our bucket. If there are any, override them.
  for (var i = 0; i < bucket.length; i++) {
    var tuple = bucket[i];
    if (tuple[0] === key) {
      //overide value stored at this key
      tuple[1] = value;
      override = true;
    }
  }

  if (!override) {
    //create a new tuple in our bucket
    //note that this could either be the new empty bucket we created above
    //or a bucket with other tupules with keys that are different than 
    //the key of the tuple we are inserting. These tupules are in the same
    //bucket because their keys all equate to the same numeric index when
    //passing through our hash function.
    bucket.push([key, value]);
    this._count++
      //now that we've added our new key/val pair to our storage
      //let's check to see if we need to resize our storage
      if (this._count > this._limit * 0.75) {
        this.resize(this._limit * 2);
      }
  }
  return this;
};


HashTable.prototype.remove = function(key) {
  var index = this.hashFunc(key, this._limit);
  var bucket = this._storage[index];
  if (!bucket) {
    return null;
  }
  //iterate over the bucket
  for (var i = 0; i < bucket.length; i++) {
    var tuple = bucket[i];
    //check to see if key is inside bucket
    if (tuple[0] === key) {
      //if it is, get rid of this tuple
      bucket.splice(i, 1);
      this._count--;
      if (this._count < this._limit * 0.25) {
        this._resize(this._limit / 2);
      }
      return tuple[1];
    }
  }
};



HashTable.prototype.retrieve = function(key) {
  var index = this.hashFunc(key, this._limit);
  var bucket = this._storage[index];

  if (!bucket) {
    return null;
  }

  for (var i = 0; i < bucket.length; i++) {
    var tuple = bucket[i];
    if (tuple[0] === key) {
      return tuple[1];
    }
  }

  return null;
};


HashTable.prototype.hashFunc = function(str, max) {
  var hash = 0;
  for (var i = 0; i < str.length; i++) {
    var letter = str[i];
    hash = (hash << 5) + letter.charCodeAt(0);
    hash = (hash & hash) % max;
  }
  return hash;
};


HashTable.prototype.resize = function(newLimit) {
  var oldStorage = this._storage;

  this._limit = newLimit;
  this._count = 0;
  this._storage = [];

  oldStorage.forEach(function(bucket) {
    if (!bucket) {
      return;
    }
    for (var i = 0; i < bucket.length; i++) {
      var tuple = bucket[i];
      this.insert(tuple[0], tuple[1]);
    }
  }.bind(this));
};


HashTable.prototype.retrieveAll = function() {
  console.log(this._storage);
  //console.log(this._limit);
};

/******************************TESTS*******************************/

var hashT = new HashTable();

hashT.insert('Alex Hawkins', '510-599-1930');
//hashT.retrieve();
//[ , , , [ [ 'Alex Hawkins', '510-599-1930' ] ] ]
hashT.insert('Boo Radley', '520-589-1970');
//hashT.retrieve();
//[ , [ [ 'Boo Radley', '520-589-1970' ] ], , [ [ 'Alex Hawkins', '510-599-1930' ] ] ]
hashT.insert('Vance Carter', '120-589-1970').insert('Rick Mires', '520-589-1970').insert('Tom Bradey', '520-589-1970').insert('Biff Tanin', '520-589-1970');
//hashT.retrieveAll();
/* 
[ ,
  [ [ 'Boo Radley', '520-589-1970' ],
    [ 'Tom Bradey', '520-589-1970' ] ],
  ,
  [ [ 'Alex Hawkins', '510-599-1930' ],
    [ 'Rick Mires', '520-589-1970' ] ],
  ,
  ,
  [ [ 'Biff Tanin', '520-589-1970' ] ] ]
*/

//overide example (Phone Number Change)
//
hashT.insert('Rick Mires', '650-589-1970').insert('Tom Bradey', '818-589-1970').insert('Biff Tanin', '987-589-1970');
//hashT.retrieveAll();

/* 
[ ,
  [ [ 'Boo Radley', '520-589-1970' ],
    [ 'Tom Bradey', '818-589-1970' ] ],
  ,
  [ [ 'Alex Hawkins', '510-599-1930' ],
    [ 'Rick Mires', '650-589-1970' ] ],
  ,
  ,
  [ [ 'Biff Tanin', '987-589-1970' ] ] ]

*/

hashT.remove('Rick Mires');
hashT.remove('Tom Bradey');
//hashT.retrieveAll();

/* 
[ ,
  [ [ 'Boo Radley', '520-589-1970' ] ],
  ,
  [ [ 'Alex Hawkins', '510-599-1930' ] ],
  ,
  ,
  [ [ 'Biff Tanin', '987-589-1970' ] ] ]


*/

hashT.insert('Dick Mires', '650-589-1970').insert('Lam James', '818-589-1970').insert('Ricky Ticky Tavi', '987-589-1970');
hashT.retrieveAll();


/* NOTICE HOW HASH TABLE HAS NOW DOUBLED IN SIZE UPON REACHING 75% CAPACITY ie 6/8. It is now size 16.
 [,
  ,
  [ [ 'Vance Carter', '120-589-1970' ] ],
  [ [ 'Alex Hawkins', '510-599-1930' ],
    [ 'Dick Mires', '650-589-1970' ],
    [ 'Lam James', '818-589-1970' ] ],
  ,
  ,
  ,
  ,
  ,
  [ [ 'Boo Radley', '520-589-1970' ],
    [ 'Ricky Ticky Tavi', '987-589-1970' ] ],
  ,
  ,
  ,
  ,
  [ [ 'Biff Tanin', '987-589-1970' ] ] ]




*/
console.log(hashT.retrieve('Lam James'));  //818-589-1970
console.log(hashT.retrieve('Dick Mires')); //650-589-1970
console.log(hashT.retrieve('Ricky Ticky Tavi')); //987-589-1970
console.log(hashT.retrieve('Alex Hawkins')); //510-599-1930
console.log(hashT.retrieve('Lebron James')); //null

Aşağıdakileri kullanarak bir tane oluşturabilirsiniz:

var dictionary = { Name:"Some Programmer", Age:24, Job:"Writing Programs"  };

//Iterate Over using keys
for (var key in dictionary) {
  console.log("Key: " + key + " , " + "Value: "+ dictionary[key]);
}

//access a key using object notation:
console.log("Her Name is: " + dictionary.Name)