Wie assoziatives Array tun / in JavaScript Hashing

https://stackoverflow.com/questions/1208222

05-07-2019
|

Frage

Ich brauche ein paar Statistiken speichern mit Hilfe von JavaScript in einer Art und Weise, 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 eine Hashtable oder so etwas wie Dictionary<TKey, TValue> in JavaScript?
Wie könnte ich speichern Werte so?

Lösung

Verwenden Sie JavaScript-Objekte als assoziative Arrays .

assoziatives Array: In einfachen Worten assoziative Arrays verwenden Strings statt Integer Zahlen als Index
.

Erstellen Sie ein Objekt mit

var dictionary = {};

Javascript können Sie Eigenschaften auf Objekte hinzufügen, indem Sie die folgende Syntax:

Object.yourProperty = value;

Eine alternative Syntax für das gleiche ist:

Object["yourProperty"] = value;

Wenn Sie auch Schlüssel zum Wertobjekt Karten mit folgenden Syntax erstellen

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

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

Sie können eine assoziative Array durchlaufen die Schleife for..in Konstrukt wie folgt

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

Andere Tipps

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

Wenn Sie von einer objektorientierten Sprache kommen sollten Sie überprüfen, diesem Artikel .

Es sei denn, Sie haben einen bestimmten Grund nicht an, nur ein normales Objekt zu verwenden. Objekteigenschaften in Javascript können referenziert werden unter Verwendung von Hash-Tabelle-Stil Syntax:

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

Beide foo und bar Elemente können nun dann als Bezug genommen werden:

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

Natürlich tut dies bedeuten, dass Ihre Schlüssel haben Strings sein. Wenn sie keine Strings sie intern in Strings umgewandelt werden, so kann es immer noch funktionieren, YMMV.

Alle modernen Browser unterstützen eine Javascript- Karte Objekt. Es gibt ein paar Gründe, die eine Karte besser als Objekt machen mit:

Ein Objekt hat einen Prototyp, so gibt es Standardschlüssel in der Karte an.

Die Schlüssel eines Objekts sind Strings, wo sie jeder Wert für eine Karte sein kann.

Sie können die Größe einer Karte leicht erhalten, während Sie für ein Objekt verfolgen Größe zu halten haben.

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, die Schlüssel von anderen Objekten referenziert werden, nicht Müll gesammelt werden, sollten Sie mit einem

Da jedes Objekt in JS verhält sich wie - und wird in der Regel umgesetzt, wie - eine Hash-Tabelle, gehe ich nur mit, dass ...

var hashSweetHashTable = {};

so in C # der Code wie folgt aussieht:

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 konnten wir die hasOwnProperty wie

verwenden

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

Wenn Sie Ihre Schlüssel benötigen eher ein beliebiges Objekt sein als nur Strings dann könnte man meinen jshashtable .

ich diese erstellt ein Problem zu lösen, wie Objektschlüssel-Mapping, die Fähigkeit der Aufzählung (mit forEach()-Methode) und Clearing.

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 mit dem angegebenen Schlüssel zugeordnet
Parameter:.
key. Der Schlüssel, von dem Sie den Wert abrufen
put(key, value)
Associates der angegebene Wert auf den angegebenen Schlüssel
Parameter:.
key: Der Schlüssel zu dem assoziieren den Wert
. value: Der Wert, der den Schlüssel zugeordnet wird
remove(key)
Entfernt den angegebenen Schlüssel mit seinem Wert
Parameter:.
key. Der Schlüssel zu entfernen
clear()
Löscht alle Hash-Tabelle, das Entfernen sowohl die Schlüssel und Werte.
indexOfKey(key)
Gibt den Index des angegebenen Schlüssel, bezogen auf das Hinzufügen, um
Parameter:.
key. Der Schlüssel davon erhält den Index
indexOfValue(value)
Gibt den Index des angegebenen Wertes, bezogen auf das Hinzufügen, um
Parameter:.
value: Der Wert davon erhalten den Index
Weitere Informationen:.
Diese Informationen werden von indexOf() Verfahren eines Arrays wiedergewonnen, so vergleicht er Objekt nur mit toString() Methode.
entryAt(index)
Gibt ein Objekt mit zwei Eigenschaften:. Schlüssel und Wert, die den Eintrag am angegebenen Index
Parameter:
index. Der Index des Eintrags zu erhalten
containsKey(key)
Gibt an, ob die Hash-Tabelle den angegebenen Schlüssel enthält
Parameter:.
key. Der Schlüssel zu überprüfen
containsValue(value)
Gibt an, ob die Hash-Tabelle mit dem angegebenen Wert enthält
Parameter:.
value. Der Wert zu überprüfen
forEach(iterator)
Iteriert alle Einträge in der angegebenen iterator
Parameter:.
value: ein Verfahren mit 3 Parametern:. key, value und index, wo index den Index des Eintrags repräsentiert

Eigenschaften:
length ( Read-only )
Ruft die Anzahl der Einträge in der Hash-Tabelle.
keys ( Read-only )
Ruft ein Array aller Schlüssel in der Hash-Tabelle.
values ( Read-only )
Ruft ein Array aller Werte in der Hash-Tabelle.
entries ( Read-only )
Ruft ein Array aller Einträge in der Hash-Tabelle. Sie sind in der gleichen Form des Verfahrens entryAt() dargestellt.

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

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 erstellen mit wie folgt aus:

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)

Lizenziert unter: CC-BY-SA mit Zuschreibung

Nicht verbunden mit StackOverflow

Wie assoziatives Array tun / in JavaScript Hashing

Dokumentation der Klasse Hashtable

Methoden:

Eigenschaften:

Dokumentation der Klasse `Hashtable`