正如在这个答案的第3个更新中所明确的那样，这种表示法：
var hash = {};
hash[X]
在 JavaScript 中，X 对象并没有被真正进行哈希，实际上它只是将 X 转换为字符串（如果它是一个对象，则通过 .toString() 进行转换，或者对于各种原始类型使用其他内置转换），然后在 "hash" 中查找该字符串，而不是对其进行哈希。也不会检查对象的相等性 - 如果两个不同的对象具有相同的字符串转换，则它们将互相覆盖。
鉴于此，是否存在有效的 JavaScript 哈希映射实现？
（例如，在javascript hashmap 的第二个 Google 结果中，提供了一个在任何操作中都是 O(n) 的实现。各种其他结果忽略了具有等效字符串表示的不同对象互相覆盖的事实。）
var key = function(obj){
// Some unique object-dependent key
return obj.totallyUniqueEmployeeIdKey; // Just an example
};
var dict = {};
dict[key(obj1)] = obj1;
dict[key(obj2)] = obj2;
你怎么知道他们用哈希表？
有三种主要方法可以通过键来定位对象的集合：
显然，JavaScript对象以某种形式使用哈希表处理一般情况。
浏览器供应商真的使用哈希表吗？
真的。
他们处理冲突吗？
是的。请参见上面的内容。如果您发现不相等字符串上有冲突，请毫不犹豫地向供应商报告错误。
那么你的想法是什么？
如果要对对象进行哈希，请找出使其唯一的内容并将其用作键。不要尝试计算实际哈希或模拟哈希表——它已经由底层JavaScript对象高效处理。
使用JavaScript的Object与此键配合使用，以利用其内置的哈希表，同时避免与默认属性可能发生冲突。
以下是一些示例：
我使用了您的建议并缓存了所有对象，使用用户名。但是有个聪明人名字叫"toString"，这是一个内置属性！现在我该怎么办？
显然，如果生成的键值只包含拉丁字符，则应该采取一些措施。例如，在开头或结尾添加任何您喜欢的非拉丁Unicode字符以避免与默认属性冲突："#toString"，"#MarySmith"。如果使用复合键，请使用某种非拉丁分隔符分隔键组件："name，city，state"。dict[key] = value进行比较。JavaScript没有内置的通用map类型（有时称为关联数组或字典），该类型允许通过任意键访问任意值。 JavaScript的基本数据结构是对象，一种特殊类型的映射，它仅接受字符串作为键，并具有特殊的语义，如原型继承、getter和setter以及其他一些魔法。
当使用对象作为映射时，您必须记住，键将通过toString()转换为字符串值，这导致将5和'5'映射到相同的值，所有未覆盖toString()方法的对象都会被索引为'[object Object]'。如果您不检查hasOwnProperty()，还可能无意中访问其继承属性。
JavaScript的内置array类型没有帮助：JavaScript数组不是关联数组，而只是带有一些更多特殊属性的对象。如果您想知道为什么它们不能用作映射，请看看这里。
Eugene Lazutkin已经描述了使用自定义哈希函数生成唯一字符串的基本思路，这些字符串可以用作字典对象的属性查找相关值。这很可能是最快的解决方案，因为对象在内部实现为哈希表。
为了为任意对象获取唯一的哈希值，一种可能性是使用全局计数器，并将哈希值缓存在对象本身中（例如，在名为__hash的属性中）。
一个同时适用于原始值和对象的哈希函数是：
function hash(value) {
return (typeof value) + ' ' + (value instanceof Object ?
(value.__hash || (value.__hash = ++arguments.callee.current)) :
value.toString());
}
hash.current = 0;
这个函数可以像Eugene描述的那样使用。为了方便起见，我们将进一步将其包装在一个Map类中。
Map实现以下实现还将键值对存储在双向链表中，以便快速迭代键和值。要提供自己的哈希函数，可以在创建后覆盖实例的hash()方法。
// Linking the key-value-pairs is optional.
// If no argument is provided, linkItems === undefined, i.e. !== false
// --> linking will be enabled
function Map(linkItems) {
this.current = undefined;
this.size = 0;
if(linkItems === false)
this.disableLinking();
}
Map.noop = function() {
return this;
};
Map.illegal = function() {
throw new Error("illegal operation for maps without linking");
};
// Map initialisation from an existing object
// doesn't add inherited properties if not explicitly instructed to:
// omitting foreignKeys means foreignKeys === undefined, i.e. == false
// --> inherited properties won't be added
Map.from = function(obj, foreignKeys) {
var map = new Map;
for(var prop in obj) {
if(foreignKeys || obj.hasOwnProperty(prop))
map.put(prop, obj[prop]);
}
return map;
};
Map.prototype.disableLinking = function() {
this.link = Map.noop;
this.unlink = Map.noop;
this.disableLinking = Map.noop;
this.next = Map.illegal;
this.key = Map.illegal;
this.value = Map.illegal;
this.removeAll = Map.illegal;
return this;
};
// Overwrite in Map instance if necessary
Map.prototype.hash = function(value) {
return (typeof value) + ' ' + (value instanceof Object ?
(value.__hash || (value.__hash = ++arguments.callee.current)) :
value.toString());
};
Map.prototype.hash.current = 0;
// --- Mapping functions
Map.prototype.get = function(key) {
var item = this[this.hash(key)];
return item === undefined ? undefined : item.value;
};
Map.prototype.put = function(key, value) {
var hash = this.hash(key);
if(this[hash] === undefined) {
var item = { key : key, value : value };
this[hash] = item;
this.link(item);
++this.size;
}
else this[hash].value = value;
return this;
};
Map.prototype.remove = function(key) {
var hash = this.hash(key);
var item = this[hash];
if(item !== undefined) {
--this.size;
this.unlink(item);
delete this[hash];
}
return this;
};
// Only works if linked
Map.prototype.removeAll = function() {
while(this.size)
this.remove(this.key());
return this;
};
// --- Linked list helper functions
Map.prototype.link = function(item) {
if(this.size == 0) {
item.prev = item;
item.next = item;
this.current = item;
}
else {
item.prev = this.current.prev;
item.prev.next = item;
item.next = this.current;
this.current.prev = item;
}
};
Map.prototype.unlink = function(item) {
if(this.size == 0)
this.current = undefined;
else {
item.prev.next = item.next;
item.next.prev = item.prev;
if(item === this.current)
this.current = item.next;
}
};
// --- Iterator functions - only work if map is linked
Map.prototype.next = function() {
this.current = this.current.next;
};
Map.prototype.key = function() {
return this.current.key;
};
Map.prototype.value = function() {
return this.current.value;
};
以下脚本，
var map = new Map;
map.put('spam', 'eggs').
put('foo', 'bar').
put('foo', 'baz').
put({}, 'an object').
put({}, 'another object').
put(5, 'five').
put(5, 'five again').
put('5', 'another five');
for(var i = 0; i++ < map.size; map.next())
document.writeln(map.hash(map.key()) + ' : ' + map.value());
string spam : eggs
string foo : baz
object 1 : an object
object 2 : another object
number 5 : five again
string 5 : another five
PEZ建议重写toString()方法，预计用我们的哈希函数。这是不可行的，因为它对基本值不起作用（改变基本值的toString()是一个非常糟糕的想法）。如果我们想让toString()返回任意对象的有意义的值，我们将不得不修改Object.prototype，有些人（包括我自己）认为这是禁止的。
我的Map实现的当前版本以及其他JavaScript好玩的东西可以从这里获得。
，并在Map构造函数中执行this._hash = 'object ' + Map._counter++。然后，hash()变成return (value && value._hash) || (typeof(value) + ' ' + String(value));`。 - broofavar myMap = new Map();
var keyString = "a string",
keyObj = {},
keyFunc = function () {};
// Setting the values
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
// Getting the values
myMap.get(keyString); // "value associated with 'a string'"
myMap.get(keyObj); // "value associated with keyObj"
myMap.get(keyFunc); // "value associated with keyFunc"
o = {}和map.set(o, 42)并改变o，那么map.get(o)仍将起作用。 - Luke Miles这里有一种简单方便的方法，可以使用类似于Java Map的东西：
var map = {
'map_name_1': map_value_1,
'map_name_2': map_value_2,
'map_name_3': map_value_3,
'map_name_4': map_value_4
}
获取该值的方法：
alert(map['map_name_1']); // Gives the value of map_value_1
... etc. ...
您可以使用 ECMAScript 6 的 WeakMap 或 Map：
WeakMap是一种键/值映射，其中键是对象。Map对象是简单的键/值映射。任何值（包括对象和原始值）都可以用作键或值。
请注意，两者都没有得到广泛支持，但您可以使用 ECMAScript 6 Shim（需要本机 ECMAScript 5 或 ECMAScript 5 Shim）来支持 Map，但不支持 WeakMap（了解原因）。
您需要在一些内部状态中存储对象/值对的联排：
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];
}
}
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));
当然，这个实现也是O（n）级别的。尤金的例子是获得哈希速度符合实际预期的唯一方法。
另一种方法，沿用尤金的答案，是以某种方式为所有对象附加唯一ID。我最喜欢的方法之一是使用从Object超类继承的内置方法之一，将其替换为自定义函数传递，并将属性附加到该函数对象。如果您要重写我的HashMap方法来执行此操作，则会看起来像：
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];
}
这个版本似乎只是稍微快一点，但理论上对于大数据集来说它将会显著提高速度。
很不幸，之前的回答都无法满足我的情况：不同的键对象可能具有相同的哈希码。因此，我写了一个简单的类似Java的HashMap版本：
function HashMap() {
this.buckets = {};
}
HashMap.prototype.put = function(key, value) {
var hashCode = key.hashCode();
var bucket = this.buckets[hashCode];
if (!bucket) {
bucket = new Array();
this.buckets[hashCode] = bucket;
}
for (var i = 0; i < bucket.length; ++i) {
if (bucket[i].key.equals(key)) {
bucket[i].value = value;
return;
}
}
bucket.push({ key: key, value: value });
}
HashMap.prototype.get = function(key) {
var hashCode = key.hashCode();
var bucket = this.buckets[hashCode];
if (!bucket) {
return null;
}
for (var i = 0; i < bucket.length; ++i) {
if (bucket[i].key.equals(key)) {
return bucket[i].value;
}
}
}
HashMap.prototype.keys = function() {
var keys = new Array();
for (var hashKey in this.buckets) {
var bucket = this.buckets[hashKey];
for (var i = 0; i < bucket.length; ++i) {
keys.push(bucket[i].key);
}
}
return keys;
}
HashMap.prototype.values = function() {
var values = new Array();
for (var hashKey in this.buckets) {
var bucket = this.buckets[hashKey];
for (var i = 0; i < bucket.length; ++i) {
values.push(bucket[i].value);
}
}
return values;
}
注意：关键对象必须“实现”hashCode()和equals()方法。
new Array() 而不是 [] 的偏好是为了确保你的代码具有绝对的 Java 风格吗？ :) - Erik Kaplun我已经实现了一个JavaScript HashMap，其代码可以从http://github.com/lambder/HashMapJS/tree/master获取。
以下是代码：
/*
=====================================================================
@license MIT
@author Lambder
@copyright 2009 Lambder.
@end
=====================================================================
*/
var HashMap = function() {
this.initialize();
}
HashMap.prototype = {
hashkey_prefix: "<#HashMapHashkeyPerfix>",
hashcode_field: "<#HashMapHashkeyPerfix>",
initialize: function() {
this.backing_hash = {};
this.code = 0;
},
/*
Maps value to key returning previous association
*/
put: function(key, value) {
var prev;
if (key && value) {
var hashCode = key[this.hashcode_field];
if (hashCode) {
prev = this.backing_hash[hashCode];
} else {
this.code += 1;
hashCode = this.hashkey_prefix + this.code;
key[this.hashcode_field] = hashCode;
}
this.backing_hash[hashCode] = value;
}
return prev;
},
/*
Returns value associated with given key
*/
get: function(key) {
var value;
if (key) {
var hashCode = key[this.hashcode_field];
if (hashCode) {
value = this.backing_hash[hashCode];
}
}
return value;
},
/*
Deletes association by given key.
Returns true if the association existed, false otherwise
*/
del: function(key) {
var success = false;
if (key) {
var hashCode = key[this.hashcode_field];
if (hashCode) {
var prev = this.backing_hash[hashCode];
this.backing_hash[hashCode] = undefined;
if(prev !== undefined)
success = true;
}
}
return success;
}
}
//// Usage
// Creation
var my_map = new HashMap();
// Insertion
var a_key = {};
var a_value = {struct: "structA"};
var b_key = {};
var b_value = {struct: "structB"};
var c_key = {};
var c_value = {struct: "structC"};
my_map.put(a_key, a_value);
my_map.put(b_key, b_value);
var prev_b = my_map.put(b_key, c_value);
// Retrieval
if(my_map.get(a_key) !== a_value){
throw("fail1")
}
if(my_map.get(b_key) !== c_value){
throw("fail2")
}
if(prev_b !== b_value){
throw("fail3")
}
// Deletion
var a_existed = my_map.del(a_key);
var c_existed = my_map.del(c_key);
var a2_existed = my_map.del(a_key);
if(a_existed !== true){
throw("fail4")
}
if(c_existed !== false){
throw("fail5")
}
if(a2_existed !== false){
throw("fail6")
}
HashMap中。 - Erik Kaplunvar wm1 = new WeakMap(),
wm2 = new WeakMap(),
wm3 = new WeakMap();
var o1 = {},
o2 = function(){},
o3 = window;
wm1.set(o1, 37);
wm1.set(o2, "azerty");
wm2.set(o1, o2); // A value can be anything, including an object or a function
wm2.set(o3, undefined);
wm2.set(wm1, wm2); // Keys and values can be any objects. Even WeakMaps!
wm1.get(o2); // "azerty"
wm2.get(o2); // Undefined, because there is no value for o2 on wm2
wm2.get(o3); // Undefined, because that is the set value
wm1.has(o2); // True
wm2.has(o2); // False
wm2.has(o3); // True (even if the value itself is 'undefined')
wm3.set(o1, 37);
wm3.get(o1); // 37
wm3.clear();
wm3.get(o1); // Undefined, because wm3 was cleared and there is no value for o1 anymore
wm1.has(o1); // True
wm1.delete(o1);
wm1.has(o1); // False
但是:
由于引用较弱，WeakMap的键不可枚举（即没有方法可以给您列出键的列表）。