Ich muss einige Statistiken mit JavaScript so speichern, wie ich es in C # tun würde:

Dictionary<string, int> statistics;

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

Gibt es ein Hashtableoder so etwas Dictionary<TKey, TValue>in JavaScript?
Wie kann ich Werte so speichern?

Verwenden Sie JavaScript-Objekte als assoziative Arrays .

Assoziatives Array: In einfachen Worten verwenden assoziative Arrays Strings anstelle von Integer-Zahlen als Index.

Erstellen Sie ein Objekt mit

var dictionary = {};

Mit Javascript können Sie Objekten mithilfe der folgenden Syntax Eigenschaften hinzufügen:

Object.yourProperty = value;

Eine alternative Syntax für dasselbe ist:

Object["yourProperty"] = value;

Wenn Sie auch Schlüssel zur Bewertung von Objektzuordnungen mit der folgenden Syntax erstellen können

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

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

Sie können ein assoziatives Array mit dem for..in-Schleifenkonstrukt wie folgt durchlaufen

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

Wenn Sie aus einer objektorientierten Sprache kommen, sollten Sie diesen Artikel lesen .

Alle modernen Browser unterstützen ein Javascript- Map- Objekt. Es gibt mehrere Gründe, die die Verwendung einer Karte besser machen als ein Objekt:

• Ein Objekt hat einen Prototyp, daher gibt es Standardschlüssel in der Karte.
• Die Schlüssel eines Objekts sind Zeichenfolgen, wobei sie einen beliebigen Wert für eine Karte haben können.
• Sie können die Größe einer Karte leicht ermitteln, während Sie die Größe eines Objekts verfolgen müssen.

Beispiel:

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"

Wenn Sie möchten, dass Schlüssel, auf die nicht von anderen Objekten verwiesen wird, als Müll gesammelt werden, sollten Sie eine WeakMap anstelle einer Map verwenden.

Verwenden Sie einfach ein normales Objekt, es sei denn, Sie haben einen bestimmten Grund, dies nicht zu tun. Auf Objekteigenschaften in Javascript kann mithilfe der Syntax im Hashtable-Stil verwiesen werden:

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

Beide foound barElemente können nun wie folgt referenziert werden:

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

Dies bedeutet natürlich, dass Ihre Schlüssel Zeichenfolgen sein müssen. Wenn es sich nicht um Zeichenfolgen handelt, werden sie intern in Zeichenfolgen konvertiert, sodass dies möglicherweise weiterhin funktioniert, YMMV.

Da sich jedes Objekt in JS wie eine Hashtabelle verhält und im Allgemeinen als Hashtabelle implementiert wird, gehe ich einfach so vor ...

var hashSweetHashTable = {};

In C # sieht der Code also so aus:

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

oder

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

in JavaScript

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

C # Dictionary - Objekt enthält nützliche Methoden wie dictionary.ContainsKey() in JavaScript wir das nutzen könnten hasOwnPropertywie

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

Wenn Sie möchten, dass Ihre Schlüssel ein beliebiges Objekt sind und nicht nur Zeichenfolgen, können Sie meine jshashtable verwenden .

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

Ich habe dies erstellt, um ein Problem zu lösen, wie z. B. Objektschlüsselzuordnung, Aufzählungsfähigkeit (mit forEach()Methode) und Löschen.

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

Dokumentation der Klasse Hashtable

Methoden:

• get(key)
  Gibt den Wert zurück, der dem angegebenen Schlüssel zugeordnet ist.
  Parameter ::
  key Der Schlüssel, von dem der Wert abgerufen wird.

• put(key, value)
  Ordnet den angegebenen Wert dem angegebenen Schlüssel zu.
  Parameter ::
  key Der Schlüssel, dem der Wert zugeordnet ist.
  value: Der Wert, der dem Schlüssel zugeordnet werden soll.

• remove(key)
  Entfernt den angegebenen Schlüssel mit seinem Wert.
  Parameter ::
  key Der zu entfernende Schlüssel.

• clear()
  Löscht alle Hashtabellen und entfernt sowohl die Schlüssel als auch die Werte.

• indexOfKey(key)
  Gibt den Index des angegebenen Schlüssels basierend auf der Additionsreihenfolge zurück.
  Parameter ::
  key Der Schlüssel, der den Index erhält.

• indexOfValue(value)
  Gibt den Index des angegebenen Werts basierend auf der Additionsreihenfolge zurück.
  Parameter ::
  value Der Wert, dessen Index abgerufen wird.
  Hinweise:
  Diese Informationen werden von der indexOf()Methode eines Arrays abgerufen , sodass das Objekt nur mit der toString()Methode verglichen wird.

• entryAt(index)
  Gibt ein Objekt mit zwei Eigenschaften zurück: Schlüssel und Wert, die den Eintrag am angegebenen Index darstellen.
  Parameter ::
  index Der Index des abzurufenden Eintrags.

• containsKey(key)
  Gibt zurück, ob die Hashtabelle den angegebenen Schlüssel enthält.
  Parameter ::
  key Der zu überprüfende Schlüssel.

• containsValue(value)
  Gibt zurück, ob die Hashtabelle den angegebenen Wert enthält.
  Parameter ::
  value Der zu überprüfende Wert.

• forEach(iterator)
  Iteriert alle Einträge in der angegebenen iterator.
  Parameter ::
  value Eine Methode mit 3 Parametern : key, valueund index, wobei indexder Index des Eintrags dargestellt wird.

  Eigenschaften:

• length ( Schreibgeschützt )
  Ruft die Anzahl der Einträge in der Hashtabelle ab.

• keys ( Schreibgeschützt )
  Ruft ein Array aller Schlüssel in der Hashtabelle ab.

• values ( Schreibgeschützt )
  Ruft ein Array aller Werte in der Hashtabelle ab.

• entries ( Schreibgeschützt )
  Ruft ein Array aller Einträge in der Hashtabelle ab. Sie werden in der gleichen Form der Methode dargestellt 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

Sie können eine erstellen, indem Sie Folgendes verwenden:

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)