有 JavaScript 的 hashmap 库吗？

Question

在 JavaScript 中，所有对象的行为有点像 hashmap。但是，这些哈希映射的键必须是字符串。如果不是，则使用toString() 进行转换。这意味着：

var a = {foo: 1};
var b = {bar: 2};
var o = {};
o[a] = 100;
o[b];              // 100
JSON.stringify(o); // '{"[object Object]":100}'

也就是说，由于任何普通 Object 的 toString() 都是 [object Object]，它们都寻址相同的值。

我想创建一个哈希图，其中具有相同属性和值的对象处理相同的值，但具有不同属性或值的对象处理不同的值。那就是：

var a = {foo: 1};
var b = {bar: 2, baz: 3};
var c = {baz: 3, bar: 2};
var hash = new Hash();
hash.set(a, 100);
hash.get(b);      // undefined
hash.set(b, 200);
hash.get(b);      // 200
hash.get(c);      // 200

我的第一直觉是使用JSON.stringify() 将对象变成字符串，但是：

var hash = {};
var b = {bar: 2, baz: 3};
var c = {baz: 3, bar: 2};
hash[JSON.stringify(b)] = 100
hash[JSON.stringify(b)] // 100
hash[JSON.stringify(c)] // undefined
JSON.stringify(b)       // '{"bar":2,"baz":3}'
JSON.stringify(c)       // '{"baz":3,"bar":2}'

即JSON序列化是顺序依赖的。

有没有好的库或技术来实现这样的哈希图？

更新：

等效地，是否有一个很好的散列函数：

hash({foo: 1, bar: 2}) == hash({bar: 2, foo: 1})

Answer 1

这是一个老问题，但 ES6 有一个可能相关的特性：Map

地图可以有任意对象作为键，任意值作为值。主要区别在于用作键的对象保持唯一，即使对象相同。

这是一个例子：

var map = new WeakMap();

var o1 = {x: 1};
var o2 = {x: 1};

map.set(o1, 'first object');
map.set(o2, 'second object');

// The keys are unique despite the objects being identical.

map.get(o1); // 'first object'
map.get(o2); // 'second object'
map.get({x: 1}); // undefined

JSON.stringifying 对象将无法区分 o1 和 o2。

MDN 有more info。还有一个 WeakMap 不维护对用作键的对象的引用，因此它们可能会被垃圾回收。

Traceur compiler 还没有 Map 和 Weakmap 的官方 polyfill，但是有一个开放的 pull request，其中包含两者的 polyfill。这些 polyfill 的代码（如果有人想单独添加它们）在这里：Map 和 WeakMap。假设这些 polyfill 运行良好，您可以立即开始使用 Map 或 WeakMap。 :)

Answer 2

这个帖子实际上让我发现了我当前项目中的一个错误。但是，现在已解决此问题，我的项目 (https://github.com/Airblader/jsava) 中的 HashMap 实现将完全按照您的描述进行。与 jshashtable 不同，没有存储桶。

Answer 3

答案是使用两个数组，一个用于键，一个用于值。

var i = keys.indexOf(key)
if (i == -1)
  {keys.push(key); values.push(value)}
else
  {values[i] = value; }

Answer 4

这是一个快速的概念验证...

我几乎没有测试过它，而且我敢肯定会有它无法处理的极端情况。

性能会非常低效，因为__createHash 函数需要递归遍历任何对象的成员，然后对它们进行排序，以生成满足您要求的“哈希”。

HashMap = function() {
    this.get = function(key) {
        var hash = this.__createHash(key);
        return this.__map[hash];
    };

    this.set = function(key, value) {
        var hash = this.__createHash(key);
        this.__map[hash] = value;
    };

    this.__createHash = function(key) {
        switch (typeof key) {
            case 'function':
                return 'function';

            case 'undefined':
                return 'undefined';

            case 'string':
                return '"' + key.replace('"', '""') + '"';

            case 'object':
                if (!key) {
                    return 'null';
                }

                switch (Object.prototype.toString.apply(key)) {
                    case '[object Array]':
                        var elements = [];
                        for (var i = 0; i < key.length; i++) {
                            elements.push(this.__createHash(key[i]));
                        }
                        return '[' + elements.join(',') + ']';

                    case '[object Date]':
                        return '#' + key.getUTCFullYear().toString()
                                   + (key.getUTCMonth() + 1).toString()
                                   + key.getUTCDate().toString()
                                   + key.getUTCHours().toString()
                                   + key.getUTCMinutes().toString()
                                   + key.getUTCSeconds().toString() + '#';

                    default:
                        var members = [];
                        for (var m in key) {
                            members.push(m + '=' + this.__createHash(key[m]));
                        }
                        members.sort();
                        return '{' + members.join(',') + '}';
                }

            default:
                return key.toString();
        }
    };

    this.__map = {};
}

Answer 5

jOrder 可以修改为在执行索引查找时将具有相同属性（但顺序不同）的对象视为相同。

如果您的列表中有 {bar: 2, baz: 3, val: 200} 对象，并且您之前已经在 jOrder 表上放置了合适的索引，如下所示：

var table = jOrder(data)
    .index('signature', ['bar', 'baz'], {grouped: true});

那么现在table.where([{bar: 2, baz: 3}])[0].val 将返回 200，但 table.where([{baz: 3, bar: 2}])[0].val 不会。 尽管使它不依赖于属性的顺序，但并不需要太多的努力。如果您有兴趣，请告诉我，我会尽快将修复推送到 GitHub。

Answer 6

我会向您推荐来自Tim Down 的jshashtable 项目。

Answer 7

Prototype 很好地覆盖了 Hash http://prototypejs.org/api/hash

Answer 8

您可以使用toString 实现您自己的类，以确保键的顺序。