Sie müssten Paare von Objekt/Wertpaaren in einem internen Zustand speichern:
HashMap = function(){
this._dict = [];
}
HashMap.prototype._get = function(key){
for(var i=0, couplet; couplet = this._dict[i]; i++){
if(couplet[0] === key){
return couplet;
}
}
}
HashMap.prototype.put = function(key, value){
var couplet = this._get(key);
if(couplet){
couplet[1] = value;
}else{
this._dict.push([key, value]);
}
return this; // for chaining
}
HashMap.prototype.get = function(key){
var couplet = this._get(key);
if(couplet){
return couplet[1];
}
}
Und verwenden Sie es als solches:
var color = {}; // Unique object instance
var shape = {}; // Unique object instance
var map = new HashMap();
map.put(color, "blue");
map.put(shape, "round");
console.log("Item is", map.get(color), "and", map.get(shape));
Natürlich liegt auch diese Implementierung in der Größenordnung von O(n). Eugene's Beispiele sind die einzige Möglichkeit, einen Hash zu erhalten, der mit einer Geschwindigkeit funktioniert, die man von einem echten Hash erwarten würde.
Ein anderer Ansatz, der der Antwort von Eugene entspricht, besteht darin, allen Objekten eine eindeutige ID zuzuordnen. Einer meiner Lieblingsansätze ist es, eine der eingebauten Methoden, die von der Oberklasse Object geerbt wurden, durch eine benutzerdefinierte Funktion zu ersetzen und diesem Funktionsobjekt Eigenschaften zuzuweisen. Wenn Sie meine HashMap-Methode umschreiben würden, um dies zu tun, würde sie wie folgt aussehen:
HashMap = function(){
this._dict = {};
}
HashMap.prototype._shared = {id: 1};
HashMap.prototype.put = function put(key, value){
if(typeof key == "object"){
if(!key.hasOwnProperty._id){
key.hasOwnProperty = function(key){
return Object.prototype.hasOwnProperty.call(this, key);
}
key.hasOwnProperty._id = this._shared.id++;
}
this._dict[key.hasOwnProperty._id] = value;
}else{
this._dict[key] = value;
}
return this; // for chaining
}
HashMap.prototype.get = function get(key){
if(typeof key == "object"){
return this._dict[key.hasOwnProperty._id];
}
return this._dict[key];
}
Diese Version scheint nur geringfügig schneller zu sein, aber theoretisch wird sie bei großen Datensätzen deutlich schneller sein.
