有什么好的JavaScript散列(代码/表）实现吗

在javascript中，对象实际上是一个散列实现。Java HashMap会有点假，所以我会挑战您重新思考您的需求。

直接的答案是否定的，我不认为Java的HashMap在javascript中有很好的实现。如果有的话，它一定是你可能想使用或不想使用的库的一部分，而且你当然不需要为了有一个小哈希表而包含一个库。

因此，让我们继续写一个，只是为了检查问题。如果你喜欢，你可以用它。我们将从编写一个构造函数开始，然后我们将继承Array，它是Object，但有一些有用的方法可以防止这个例子变得过于乏味：

function HashMap () {
    var obj = [];
    return obj;
}
var myHashMap = HashMap();

我们将添加一些直接来自Java世界的方法，但在进行过程中转换为javascript。。。

function HashMap() {
    var obj = [];
    obj.size = function () {
        return this.length;
    };
    obj.isEmpty = function () {
        return this.length === 0;
    };
    obj.containsKey = function (key) {
        for (var i = 0; i < this.length; i++) {
            if (this[i].key === key) {
                return i;
            }
        }
        return -1;
    };
    obj.get = function (key) {
        var index = this.containsKey(key);
        if (index > -1) {
            return this[index].value;
        }
    };
    obj.put = function (key, value) {
        if (this.containsKey(key) !== -1) {
            return this.get(key);
        }
        this.push({'key': key, 'value': value});
    };
    obj.clear = function () {
        this = null;  // Just kidding...
    };
    return obj;
}

我们可以继续建设，但我认为这是错误的做法。最后，我们最终会使用javascript在幕后提供的内容，因为我们根本没有HashMap类型。在假装的过程中，它有助于的各种额外工作。

具有讽刺意味的是，javascript之所以成为如此有趣和多样化的语言，其中一个原因是它能够轻松地处理这种摔跤。我们可以做任何我们想做的事情，这里的快速例子如果不能说明语言的欺骗性，就毫无作用。然而，考虑到这种力量，似乎最好不要使用它。

我只是觉得javascript想要更轻一些。我个人的建议是，在尝试实现一个合适的JavaHashMap之前，您应该重新检查这个问题Javascript既不想要也不提供一个。

记住本机替代方案：

var map = [{}, 'string', 4, {}];

相比之下又快又容易。

另一方面，我不相信这里有任何硬性的答案。这个实现实际上是一个完全可以接受的解决方案。如果你觉得你可以使用它，我会说试试。但如果我觉得我们有更简单、更自然的方法，我永远不会使用它。。我几乎可以肯定我们会这样做。

旁注：效率与风格有关吗？请注意性能命中。。在HashMap.put（）上，有一个很大的O正盯着我们……不太理想的性能可能不是这里的亮点，你可能需要做一些非常雄心勃勃的事情，或者拥有大量数据，然后才能注意到现代浏览器的性能问题。有趣的是，当你逆着粮食工作时，操作往往会变得不那么高效，几乎就像有一个自然熵在起作用一样。Javascript是一种高级语言，当我们与它的约定保持一致时，它应该提供高效的解决方案，就像Java中的HashMap将是一个更自然、更高性能的选择一样。

我发布了一个独立的JavaScript哈希表实现，它比这里列出的更进一步。

http://www.timdown.co.uk/jshashtable/

注意，使用"任何类型的对象"作为键的java集合都不太正确。是的，您可以使用任何对象，但除非该对象具有良好的hashcode（）和equals（）实现，否则它不会很好地工作。Object基类有一个默认的实现，但为了让自定义类（有效地）作为哈希表键工作，您需要覆盖它们。Javascript没有对等的（据我所知）。

要在javascript中创建一个可以（有效地）使用任意对象作为关键字的哈希表，您需要在使用的对象上强制执行类似的操作，至少如果您想保持哈希表的性能优势的话。如果您可以强制执行返回String的"hashcode（）"方法，那么您可以直接使用引擎盖下的Object作为实际的hashtable。

否则，你需要像发布的其他解决方案一样，这些解决方案目前的表现不像哈希表。他们都在列表上进行O（n）搜索，试图找到密钥，这几乎违背了哈希表的目的（哈希表通常是get/put的恒定时间）。

这是我刚刚提出的一个天真的实现——正如keparo在评论中提到的，其中一个大问题是平等检查：

var ObjectMap = function()
{
    this._keys = [];
    this._values = [];
};
ObjectMap.prototype.clear = function()
{
    this._keys = [];
    this._values = [];
};
ObjectMap.prototype.get = function(key)
{
    var index = this._indexOf(key, this._keys);
    if (index != -1)
    {
        return this._values[index];
    }
    return undefined;
};
ObjectMap.prototype.hasKey = function(key)
{
    return (this._indexOf(key, this._keys) != -1);
};
ObjectMap.prototype.hasValue = function(value)
{
    return (this._indexOf(value, this._values) != -1);
};
ObjectMap.prototype.put = function(key, value)
{
    var index = this._indexOf(key, this._keys);
    if (index == -1)
    {
        index = this._keys.length;
    }
    this._keys[index] = key;
    this._values[index] = value;
};
ObjectMap.prototype.remove = function(key)
{
    var index = this._indexOf(key, this._keys);
    if (index != -1)
    {
        this._keys.splice(index, 1);
        this._values.splice(index, 1);
    }
};
ObjectMap.prototype.size = function()
{
    return this._keys.length;
};
ObjectMap.prototype._indexOf = function(item, list)
{
    for (var i = 0, l = list.length; i < l; i++)
    {
        if (this._equals(list[i], item))
        {
            return i;
        }
    }
    return -1;
};
ObjectMap.prototype._equals = function(a, b)
{
    if (a === b)
    {
        return true;
    }
    // Custom objects can implement an equals method
    if (typeof a.equals == "function" &&
        typeof b.equals == "function")
    {
        return a.equals(b);
    }
    // Arrays are equal if they're the same length and their contents are equal
    if (a instanceof Array && b instanceof Array)
    {
        if (a.length != b.length)
        {
            return false;
        }
        for (var i = 0, l = a.length; i < l; i++)
        {
            if (!this._equals(a[i], b[i]))
            {
                return false;
            }
        }
        return true;
    }
    // Checking object properties - objects are equal if they have all the same
    // properties and they're all equal.
    var seenProperties = {};
    for (var prop in a)
    {
        if (a.hasOwnProperty(prop))
        {
            if (!b.hasOwnProperty(prop))
            {
                return false;
            }
            if (!this._equals(a[prop], b[prop]))
            {
                return false;
            }
            seenProperties[prop] = true;
        }
    }
    for (var prop in b)
    {
        if (!(prop in seenProperties) && b.hasOwnProperty(prop))
        {
            if (!a.hasOwnProperty(prop))
            {
                return false;
            }
            if (!this._equals(b[prop], a[prop]))
            {
                return false;
            }
        }
    }
    return true;
};

示例用法：

>>> var map = new ObjectMap();
>>> var o = {a: 1, b: [1,2], c: true};
>>> map.put(o, "buns");
>>> map.get(o)
"buns"
>>> map.get({a: 1, b: [1,2], c: true});
"buns"
>>> map.get({a: 1, b: [1,2], c: true, d:"hi"});
>>> var a = [1,2,3];
>>> map.put(a, "cheese");
>>> map.get(a);
"cheese"
>>> map.get([1,2,3]);
"cheese"
>>> map.get([1,2,3,4]);
>>> var d = new Date();
>>> map.put(d, "toast");
>>> map.get(d);
"toast"
>>> map.get(new Date(d.valueOf()));
"toast"

这绝不是一个完整的实现，只是实现这样一个对象的指针。例如，看看我给出的内容，您还需要在对象属性检查之前添加构造函数属性检查，因为这目前是有效的：

>>> function TestObject(a) { this.a = a; };
>>> var t = new TestObject("sandwich");
>>> map.put(t, "butter");
>>> map.get({a: "sandwich"})
"butter"