等效于JavaScript Hashmap


353

正如在此答案的更新3中明确指出的那样,该表示法:

var hash = {};
hash[X]

实际上不哈希对象X;它实际上只是转换X为字符串(通过.toString()它是对象还是其他各种原始类型的内置转换),然后在“ hash”中查找该字符串,而不对其进行哈希处理。也不会检查对象是否相等-如果两个不同的对象具有相同的字符串转换,则它们将彼此覆盖。

鉴于此-在JavaScript中是否有任何有效的hashmap实现?(例如,第二个Google结果javascript hashmap产生的实现对任何操作都是O(n)。其他各种结果都忽略了具有等效字符串表示形式的不同对象相互覆盖的事实。


1
@Claudiu:很抱歉编辑,但是标题中的“地图”确实令人误解。如果您不同意,请回滚,我无意光顾。:)
Tomalak

6
@Claudiu:您问了很多有关javascript的问题。好问题。我喜欢。
一些

2
@Claudiu:另外,您可以链接到您引用的Google结果吗?不同的Google本地版本会返回不同的结果,您引用的实现似乎对我来说似乎没有。
Tomalak

@Tomalak:我正要写完全一样的东西!
一些

3
@Claudiu不,不要链接到Google。链接到您正在谈论的页面(您恰巧是通过Google找到的)。链接到Google与解释搜索内容有同样的问题:google根据位置或搜索历史来自定义结果,google的结果随时间而变化(当前,这是该搜索的最高结果)以及所有其他可以实现的结果显示不同的结果。
Jasper 2014年

Answers:


369

为什么不自己手动对对象进行哈希处理,然后将结果字符串用作常规JavaScript词典的键?毕竟,您处于最佳位置,知道什么使您的对象独特。我就是做这个的。

例:

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完成的索引编制,而不会大量增加内存分配和溢出处理。

当然,如果您真正想要“工业级解决方案”,则可以构建一个由键函数参数化的类,并带有容器的所有必需API,但是…我们使用JavaScript,并试图做到简单轻巧,因此此功能解决方案既简单又快速。

密钥功能可以像选择对象的正确属性(例如,一个密钥或一组已经唯一的密钥),简单地组合在一起(唯一的密钥组合)一样简单,也可以像使用某些加密哈希一样复杂在DojoX EncodingDojoX UUID中。尽管后一种解决方案可能会产生唯一的密钥,但我个人还是不惜一切代价避免使用它们,尤其是当我知道是什么使我的对象变得唯一时。

2014年更新:早在2008年就已回答,这个简单的解决方案仍需要更多说明。让我以问答形式澄清这个想法。

您的解决方案没有真正的哈希。它在哪里???

JavaScript是一种高级语言。它的基本原语(Object)包括用于保留属性的哈希表。为了提高效率,通常用低级语言编写此哈希表。通过使用带有字符串键的简单对象,我们无需任何努力即可使用高效实现的哈希表。

您怎么知道他们使用哈希?

保持键可寻址的对象集合的三种主要方法:

  • 无序的。在这种情况下,要通过对象的键检索对象,我们必须遍历所有找到后停止的键。平均而言,将进行n / 2个比较。
  • 有序
    • 例子1:一个有序的数组—做一个二进制搜索,我们平均在〜log2(n)比较之后会找到我们的密钥。好多了。
    • 示例2:一棵树。同样,这将是〜log(n)尝试。
  • 哈希表。平均而言,它需要一个恒定的时间。比较:O(n)与O(log n)与O(1)。繁荣。

显然,JavaScript对象使用某种形式的哈希表来处理一般情况。

浏览器供应商是否真的使用哈希表???

真。

他们会处理碰撞吗?

是。往上看。如果发现不相等的字符串发生冲突,请立即向供应商提交错误报告。

那你的主意是什么?

如果要散列对象,请查找使其唯一的原因并将其用作键。不要尝试计算真实的哈希或模拟哈希表-基础JavaScript对象已经有效地处理了它。

将此键与JavaScript结合使用Object可利用其内置的哈希表,同时避免使用默认属性发生可能的冲突。

入门示例:

  • 如果您的对象包含唯一的用户名,请使用它作为键。
  • 如果它包含唯一的客户编号,请使用它作为密钥。
    • 如果它包含政府发行的唯一号码(例如SSN或护照号码),并且您的系统不允许重复,请使用它作为密钥。
  • 如果字段的组合是唯一的,则将其用作键。
    • 状态缩写+驾驶执照号码是一个很好的钥匙。
    • 国家缩写+护照号码也是一个很好的钥匙。
  • 字段上的某些函数或整个对象可以返回唯一值-将其用作键。

我使用了您的建议,并使用用户名缓存了所有对象。但是,一个聪明人被称为“ toString”,这是一个内置属性!我现在该怎么办?

显然,如果生成的键很可能仅由拉丁字符组成,那么您应该对此做一些事情。例如,在开头或结尾添加您喜欢的任何非拉丁Unicode字符,以使用默认属性“ #toString”,“#MarySmith”取消冲突。如果使用复合键,请使用某种非拉丁定界符来分隔键组件:“名称,城市,州”。

通常,这是我们必须发挥创造力的地方,并选择具有给定限制(唯一性,具有默认属性的潜在冲突)的最简单的键。

注意:根据定义,唯一键不会发生冲突,而潜在的哈希冲突将由底层进行处理Object

您为什么不喜欢工业解决方案?

恕我直言,最好的代码是根本没有代码:它没有错误,不需要维护,易于理解并且可以立即执行。我看到的所有“ JavaScript中的哈希表”都是100行以上的代码,并且涉及多个对象。与以下内容进行比较:dict[key] = value

另一点:使用JavaScript和完全相同的原始对象来实现已经实现的东西,甚至有可能击败以低级语言编写的原始对象的性能吗?

我仍然想散列没有任何键的对象!

我们很幸运:ECMAScript 6(计划于2015年中期发布,在此之后花上一到两年的时间才能普及)定义了 地图集合

根据定义判断,他们可以将对象的地址用作键,这使对象无需人工键即可立即与众不同。OTOH,两个不同但相同的对象,将被映射为不同的对象。

来自MDN的比较细分:

对象与Maps相似,两者都允许您将键设置为值,检索这些值,删除键并检测是否在键处存储了某些内容。因此(并且因为没有内置的替代方法),对象在历史上一直被用作地图。但是,在某些情况下,使用地图有一些重要的区别:

  • 对象的键是字符串和符号,而它们的键可以是Map的任何值,包括函数,对象和任何基元。
  • Map中的键是有序的,而添加到对象中的键则没有顺序。因此,在对其进行迭代时,Map对象将按插入顺序返回键。
  • 您可以使用size属性轻松获得Map的大小,而Object中属性的数量必须手动确定。
  • Map是可迭代的,因此可以直接进行迭代,而对Object进行迭代需要以某种方式获取其键并对其进行迭代。
  • 对象具有原型,因此如果不小心,映射中的默认键可能会与您的键冲突。从ES5开始,可以通过使用map = Object.create(null)绕过此方法,但这很少完成。
  • 在涉及频繁添加和删除密钥对的情况下,Map的性能可能更好。

13
这看起来不像是正确的地图,因为您无法处理碰撞。如果碰巧是这样:hash(obj1)== hash(obj2),您将丢失数据。
Beefather 2012年

32
当“ PAUL AINLEY”和“ PAULA INLEY”都在您的系统中注册时,天堂将为您提供帮助
Matt R

34
@MattR实际上,即使有模拟哈希函数,即使没有天堂的帮助,您的示例也可以正常工作。我希望其他读者会意识到,过度简化的非现实哈希函数被用作占位符来演示另一种技术。代码注释和答案本身都强调它不是真实的。答案的最后一段讨论了正确密钥的选择。
尤金·拉祖金

6
@EugeneLazutkin-恐怕你还是误会了。您的示例仍然容易出现哈希冲突。不要以为仅将姓氏放在第一位会对您有所帮助!
Matt R

3
@EugeneLazutkin大多数人在ES6出现之前都没有读过您的答案……让我祝贺您对JS的深入了解。
加布里埃尔·安德烈斯·布兰科里尼

171

问题描述

JavaScript没有内置的通用地图类型(有时称为关联数组字典),该类型允许通过任意键访问任意值。JavaScript的基本数据结构是object,这是一种特殊类型的map,它仅接受字符串作为键,并具有特殊的语义,例如原型继承,getter和setter以及一些其他的伏都教。

在将对象用作地图时,您必须记住,键将通过转换为字符串值toString(),这将导致映射5'5'转换为相同的值,并且所有未将toString()方法覆盖为索引的值的对象'[object Object]'。如果不选择,也可能会不由自主地访问其继承的属性hasOwnProperty()

JavaScript的内置数组类型无济于事:JavaScript数组不是关联数组,而只是具有更多特殊属性的对象。如果您想知道为什么不能将它们用作地图,请查看此处

尤金的解决方案

尤金·拉祖金(Eugene Lazutkin)已经描述了使用自定义哈希函数生成唯一字符串的基本思想,该字符串可用于查找关联值作为字典对象的属性。这很可能是最快的解决方案,因为对象在内部实现为哈希表

  • 注意:哈希表(有时称为哈希表)是映射概念的特定实现,它使用支持数组和通过数字哈希值进行查找。运行时环境可能使用其他结构(例如搜索树跳过列表)来实现JavaScript对象,但是由于对象是基本数据结构,因此应充分优化它们。

为了获得任意对象的唯一哈希值,一种可能性是使用全局计数器并将哈希值缓存在对象本身中(例如,在名为的属性中__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 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,有些人(不包括我自己)认为verboten


编辑:可从此处获得Map实现的当前版本以及其他JavaScript插件。


ES5不推荐使用被调用方(goo.gl/EeStE)。相反,我建议Map._counter = 0在Map构造函数中这样做this._hash = 'object ' + Map._counter++。然后hash()变为return (value && value._hash) || (typeof(value) + ' ' + String(value));
broofa 2012年


@Christoph,您好,您能否将链接更新到我可以找到您的Map实现的位置?
NumenorForLife

2
@ jsc123:我将对此进行调查-现在您可以在pikacode.com/mercurial.intuxication.org/js-hacks.tar.gz上找到
Christoph

58

我知道这个问题已经很老了,但是当今外部库有一些非常好的解决方案。

JavaScript还提供了其语言 Map


2
这就是前进到21世纪的方式。太糟糕了,我用一些丑陋的自制Map完成代码后才找到您的帖子。WEEE需要更多投票才能回答您的问题
Phung D.

1
Collections.js有一些实现,但是在underscore.js或lodash中找不到任何实现……您在下划线中指的是什么有用的?
编码

@CodeBling不知道。我认为我对地图功能感到困惑。我要从答案中删除它。
贾梅尔·汤姆斯

3
这还算公平。任何考虑Collections.js的人都应该意识到,它以一种有问题的方式修改了全局Array,Function,Object和Regexp原型(请参阅我在这里遇到的问题)。尽管最初我对collections.js(以及由此得到的答案)感到非常满意,但使用它的相关风险太大,因此我放弃了它。只有kriskowal的collections.jsv2分支(特别是v2.0.2 +)可以消除对全局原型的修改,并且可以安全使用。
编码

28

这是一种使用类似于Java映射的简便方法:

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'] );    // fives the value of map_value_1

......  etc  .....

2
这仅适用于字符串键。我相信OP对使用任何类型的键都感兴趣。
fractor 2017年

26

根据ECMAScript 2015(ES6),标准javascript具有Map实现。有关更多信息,请参见此处

基本用法:

var 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"

21

您可以使用ES6 WeakMapMap

  • WeakMap是键/值映射,其中键是对象。

  • Map对象是简单的键/值映射。任何值(对象值和原始值)都可以用作键或值。

请注意,两者均不受广泛支持,但是您可以使用ES6 Shim(需要本机ES5或ES5 Shim)来支持Map,但不能WeakMap请参阅原因)。


在2019年,他们得到了很好的支持,并采用了惊人的方法!developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/...
胡安马·梅嫩德斯

13

您必须在对象/值对的一些内部状态对中存储

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)的某处。上面的Eugene例子是获取散列的唯一方法,该散列可以以您期望的真实散列速度运行。

更新:

按照Eugene的回答,另一种方法是将唯一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];
}

这个版本似乎只是稍快一些,但是从理论上讲,对于大型数据集它将明显更快。


关联数组(即2元组的数组)是Map,而不是HashMap;HashMap是使用哈希值以获得更好性能的Map。
Erik Kaplun

没错,但是为什么要在这个话题上扯皮呢?由于无法获取对象内存地址,因此无法在JavaScript中创建真正的哈希映射。JavaScript的内置对象键/值对(在我的第二个示例中使用)可以充当HashMap,但不是必须的,因为它取决于浏览器中如何实现查找的运行时。
pottedmeat 2012年

11

不幸的是,以上答案都不适合我的情况:不同的键对象可能具有相同的哈希码。因此,我写了一个简单的类似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()方法。


7
new Array()over 的偏好[]是为了确保您的代码绝对类似于Java?:)
Erik Kaplun

6

我已经实现了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 assocciation
   */
  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 assocciation 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")
}

2
您的代码似乎无法将相同的对象放入多个HashMaps中。
Erik Kaplun

5

在ECMA6中,您可以使用WeakMap

例:

var 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

但:

Because of references being weak, WeakMap keys are not enumerable (i.e. there is no method giving you a list of the keys). 

哦,赞美耶稣,他们终于在javascript中添加了一些弱引用。现在是时候了……为此+1,但是实际上使用起来很糟糕,因为引用很弱
Claudiu

2

Javascript不内置Map / hashmap。它应该称为关联数组

hash["X"]等于hash.X,但允许“ X”作为字符串变量。换句话说,hash[x]在功能上等于eval("hash."+x.toString())

它更类似于object.properties,而不是键-值映射。如果您正在寻找更好的JavaScript键/值映射,请使用Map对象,您可以在网上找到它。



2

这看起来是一个非常强大的解决方案:https : //github.com/flesler/hashmap。它甚至对于看起来相同的功能和对象也能很好地工作。它使用的唯一技巧是向对象添加一个晦涩的成员以对其进行识别。如果您的程序没有覆盖那个晦涩的变量(像hashid这样的东西),那您就很高兴了


2

如果性能并不重要(例如键的量相对较小),你不想与污染像其他字段你(也许不是你的)对象_hash_id等等,那么你就可以利用这一事实Array.prototype.indexOf使用严格平等。这是一个简单的实现:

var Dict = (function(){
    // IE 8 and earlier has no Array.prototype.indexOf
    function indexOfPolyfill(val) {
      for (var i = 0, l = this.length; i < l; ++i) {
        if (this[i] === val) {
          return i;
        }
      }
      return -1;
    }

    function Dict(){
      this.keys = [];
      this.values = [];
      if (!this.keys.indexOf) {
        this.keys.indexOf = indexOfPolyfill;
      }
    };

    Dict.prototype.has = function(key){
      return this.keys.indexOf(key) != -1;
    };

    Dict.prototype.get = function(key, defaultValue){
      var index = this.keys.indexOf(key);
      return index == -1 ? defaultValue : this.values[index];
    };

    Dict.prototype.set = function(key, value){
      var index = this.keys.indexOf(key);
      if (index == -1) {
        this.keys.push(key);
        this.values.push(value);
      } else {
        var prevValue = this.values[index];
        this.values[index] = value;
        return prevValue;
      }
    };

    Dict.prototype.delete = function(key){
      var index = this.keys.indexOf(key);
      if (index != -1) {
        this.keys.splice(index, 1);
        return this.values.splice(index, 1)[0];
      }
    };

    Dict.prototype.clear = function(){
      this.keys.splice(0, this.keys.length);
      this.values.splice(0, this.values.length);
    };

    return Dict;
})();

用法示例:

var a = {}, b = {},
    c = { toString: function(){ return '1'; } },
    d = 1, s = '1', u = undefined, n = null,
    dict = new Dict();

// keys and values can be anything
dict.set(a, 'a');
dict.set(b, 'b');
dict.set(c, 'c');
dict.set(d, 'd');
dict.set(s, 's');
dict.set(u, 'u');
dict.set(n, 'n');

dict.get(a); // 'a'
dict.get(b); // 'b'
dict.get(s); // 's'
dict.get(u); // 'u'
dict.get(n); // 'n'
// etc.

与ES6 WeakMap相比,它有两个问题:O(n)搜索时间和无缺陷(即,如果不使用deleteclear释放键,将导致内存泄漏)。


2

我的地图实现(源自Christoph的示例):

用法示例:

var map = new Map();  //creates an "in-memory" map
var map = new Map("storageId");  //creates a map that is loaded/persisted using html5 storage

function Map(storageId) {
    this.current = undefined;
    this.size = 0;
    this.storageId = storageId;
    if (this.storageId) {
        this.keys = new Array();
        this.disableLinking();
    }
}

Map.noop = function() {
    return this;
};

Map.illegal = function() {
    throw new Error("illegal operation for maps without linking");
};

// map initialisation from 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)];
    if (item === undefined) {
        if (this.storageId) {
            try {
                var itemStr = localStorage.getItem(this.storageId + key);
                if (itemStr && itemStr !== 'undefined') {
                    item = JSON.parse(itemStr);
                    this[this.hash(key)] = item;
                    this.keys.push(key);
                    ++this.size;
                }
            } catch (e) {
                console.log(e);
            }
        }
    }
    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;
    if (this.storageId) {
        this.keys.push(key);
        try {
            localStorage.setItem(this.storageId + key, JSON.stringify(this[hash]));
        } catch (e) {
            console.log(e);
        }
    }
    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];
    }
    if (this.storageId) {
        try {
            localStorage.setItem(this.storageId + key, undefined);
        } catch (e) {
            console.log(e);
        }
    }
    return this;
};

// only works if linked
Map.prototype.removeAll = function() {
    if (this.storageId) {
        for (var i=0; i<this.keys.length; i++) {
            this.remove(this.keys[i]);
        }
        this.keys.length = 0;
    } else {
        while(this.size)
            this.remove(this.key());
    }
    return this;
};

// --- linked list helper functions

Map.prototype.link = function(item) {
    if (this.storageId) {
        return;
    }
    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.storageId) {
        return;
    }
    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() {
    if (this.storageId) {
        return undefined;
    } else {
        return this.current.key;
    }
};

Map.prototype.value = function() {
    if (this.storageId) {
        return undefined;
    }
    return this.current.value;
};

1

添加另一个解决方案:HashMap这几乎是我从Java移植到Javascript的第一堂课。您可以说有很多开销,但是实现几乎等于Java的实现100%,并且包括所有接口和子类。

该项目可以在这里找到:https : //github.com/Airblader/jsava 我还将附加HashMap类的(当前)源代码,但如上所述,它也取决于超级类等。使用的OOP框架是qooxdoo。

编辑:请注意,此代码已经过时,请参考github项目以获取当前工作。在撰写本文时,还有一个ArrayList实现。

qx.Class.define( 'jsava.util.HashMap', {
    extend: jsava.util.AbstractMap,
    implement: [jsava.util.Map, jsava.io.Serializable, jsava.lang.Cloneable],

    construct: function () {
        var args = Array.prototype.slice.call( arguments ),
            initialCapacity = this.self( arguments ).DEFAULT_INITIAL_CAPACITY,
            loadFactor = this.self( arguments ).DEFAULT_LOAD_FACTOR;

        switch( args.length ) {
            case 1:
                if( qx.Class.implementsInterface( args[0], jsava.util.Map ) ) {
                    initialCapacity = Math.max( ((args[0].size() / this.self( arguments ).DEFAULT_LOAD_FACTOR) | 0) + 1,
                        this.self( arguments ).DEFAULT_INITIAL_CAPACITY );
                    loadFactor = this.self( arguments ).DEFAULT_LOAD_FACTOR;
                } else {
                    initialCapacity = args[0];
                }
                break;
            case 2:
                initialCapacity = args[0];
                loadFactor = args[1];
                break;
        }

        if( initialCapacity < 0 ) {
            throw new jsava.lang.IllegalArgumentException( 'Illegal initial capacity: ' + initialCapacity );
        }
        if( initialCapacity > this.self( arguments ).MAXIMUM_CAPACITY ) {
            initialCapacity = this.self( arguments ).MAXIMUM_CAPACITY;
        }
        if( loadFactor <= 0 || isNaN( loadFactor ) ) {
            throw new jsava.lang.IllegalArgumentException( 'Illegal load factor: ' + loadFactor );
        }

        var capacity = 1;
        while( capacity < initialCapacity ) {
            capacity <<= 1;
        }

        this._loadFactor = loadFactor;
        this._threshold = (capacity * loadFactor) | 0;
        this._table = jsava.JsavaUtils.emptyArrayOfGivenSize( capacity, null );
        this._init();
    },

    statics: {
        serialVersionUID: 1,

        DEFAULT_INITIAL_CAPACITY: 16,
        MAXIMUM_CAPACITY: 1 << 30,
        DEFAULT_LOAD_FACTOR: 0.75,

        _hash: function (hash) {
            hash ^= (hash >>> 20) ^ (hash >>> 12);
            return hash ^ (hash >>> 7) ^ (hash >>> 4);
        },

        _indexFor: function (hashCode, length) {
            return hashCode & (length - 1);
        },

        Entry: qx.Class.define( 'jsava.util.HashMap.Entry', {
            extend: jsava.lang.Object,
            implement: [jsava.util.Map.Entry],

            construct: function (hash, key, value, nextEntry) {
                this._value = value;
                this._next = nextEntry;
                this._key = key;
                this._hash = hash;
            },

            members: {
                _key: null,
                _value: null,
                /** @type jsava.util.HashMap.Entry */
                _next: null,
                /** @type Number */
                _hash: 0,

                getKey: function () {
                    return this._key;
                },

                getValue: function () {
                    return this._value;
                },

                setValue: function (newValue) {
                    var oldValue = this._value;
                    this._value = newValue;
                    return oldValue;
                },

                equals: function (obj) {
                    if( obj === null || !qx.Class.implementsInterface( obj, jsava.util.HashMap.Entry ) ) {
                        return false;
                    }

                    /** @type jsava.util.HashMap.Entry */
                    var entry = obj,
                        key1 = this.getKey(),
                        key2 = entry.getKey();
                    if( key1 === key2 || (key1 !== null && key1.equals( key2 )) ) {
                        var value1 = this.getValue(),
                            value2 = entry.getValue();
                        if( value1 === value2 || (value1 !== null && value1.equals( value2 )) ) {
                            return true;
                        }
                    }

                    return false;
                },

                hashCode: function () {
                    return (this._key === null ? 0 : this._key.hashCode()) ^
                        (this._value === null ? 0 : this._value.hashCode());
                },

                toString: function () {
                    return this.getKey() + '=' + this.getValue();
                },

                /**
                 * This method is invoked whenever the value in an entry is
                 * overwritten by an invocation of put(k,v) for a key k that's already
                 * in the HashMap.
                 */
                _recordAccess: function (map) {
                },

                /**
                 * This method is invoked whenever the entry is
                 * removed from the table.
                 */
                _recordRemoval: function (map) {
                }
            }
        } )
    },

    members: {
        /** @type jsava.util.HashMap.Entry[] */
        _table: null,
        /** @type Number */
        _size: 0,
        /** @type Number */
        _threshold: 0,
        /** @type Number */
        _loadFactor: 0,
        /** @type Number */
        _modCount: 0,
        /** @implements jsava.util.Set */
        __entrySet: null,

        /**
         * Initialization hook for subclasses. This method is called
         * in all constructors and pseudo-constructors (clone, readObject)
         * after HashMap has been initialized but before any entries have
         * been inserted.  (In the absence of this method, readObject would
         * require explicit knowledge of subclasses.)
         */
        _init: function () {
        },

        size: function () {
            return this._size;
        },

        isEmpty: function () {
            return this._size === 0;
        },

        get: function (key) {
            if( key === null ) {
                return this.__getForNullKey();
            }

            var hash = this.self( arguments )._hash( key.hashCode() );
            for( var entry = this._table[this.self( arguments )._indexFor( hash, this._table.length )];
                 entry !== null; entry = entry._next ) {
                /** @type jsava.lang.Object */
                var k;
                if( entry._hash === hash && ((k = entry._key) === key || key.equals( k )) ) {
                    return entry._value;
                }
            }

            return null;
        },

        __getForNullKey: function () {
            for( var entry = this._table[0]; entry !== null; entry = entry._next ) {
                if( entry._key === null ) {
                    return entry._value;
                }
            }

            return null;
        },

        containsKey: function (key) {
            return this._getEntry( key ) !== null;
        },

        _getEntry: function (key) {
            var hash = (key === null) ? 0 : this.self( arguments )._hash( key.hashCode() );
            for( var entry = this._table[this.self( arguments )._indexFor( hash, this._table.length )];
                 entry !== null; entry = entry._next ) {
                /** @type jsava.lang.Object */
                var k;
                if( entry._hash === hash
                    && ( ( k = entry._key ) === key || ( key !== null && key.equals( k ) ) ) ) {
                    return entry;
                }
            }

            return null;
        },

        put: function (key, value) {
            if( key === null ) {
                return this.__putForNullKey( value );
            }

            var hash = this.self( arguments )._hash( key.hashCode() ),
                i = this.self( arguments )._indexFor( hash, this._table.length );
            for( var entry = this._table[i]; entry !== null; entry = entry._next ) {
                /** @type jsava.lang.Object */
                var k;
                if( entry._hash === hash && ( (k = entry._key) === key || key.equals( k ) ) ) {
                    var oldValue = entry._value;
                    entry._value = value;
                    entry._recordAccess( this );
                    return oldValue;
                }
            }

            this._modCount++;
            this._addEntry( hash, key, value, i );
            return null;
        },

        __putForNullKey: function (value) {
            for( var entry = this._table[0]; entry !== null; entry = entry._next ) {
                if( entry._key === null ) {
                    var oldValue = entry._value;
                    entry._value = value;
                    entry._recordAccess( this );
                    return oldValue;
                }
            }

            this._modCount++;
            this._addEntry( 0, null, value, 0 );
            return null;
        },

        __putForCreate: function (key, value) {
            var hash = (key === null) ? 0 : this.self( arguments )._hash( key.hashCode() ),
                i = this.self( arguments )._indexFor( hash, this._table.length );
            for( var entry = this._table[i]; entry !== null; entry = entry._next ) {
                /** @type jsava.lang.Object */
                var k;
                if( entry._hash === hash
                    && ( (k = entry._key) === key || ( key !== null && key.equals( k ) ) ) ) {
                    entry._value = value;
                    return;
                }
            }

            this._createEntry( hash, key, value, i );
        },

        __putAllForCreate: function (map) {
            var iterator = map.entrySet().iterator();
            while( iterator.hasNext() ) {
                var entry = iterator.next();
                this.__putForCreate( entry.getKey(), entry.getValue() );
            }
        },

        _resize: function (newCapacity) {
            var oldTable = this._table,
                oldCapacity = oldTable.length;
            if( oldCapacity === this.self( arguments ).MAXIMUM_CAPACITY ) {
                this._threshold = Number.MAX_VALUE;
                return;
            }

            var newTable = jsava.JsavaUtils.emptyArrayOfGivenSize( newCapacity, null );
            this._transfer( newTable );
            this._table = newTable;
            this._threshold = (newCapacity * this._loadFactor) | 0;
        },

        _transfer: function (newTable) {
            var src = this._table,
                newCapacity = newTable.length;
            for( var j = 0; j < src.length; j++ ) {
                var entry = src[j];
                if( entry !== null ) {
                    src[j] = null;
                    do {
                        var next = entry._next,
                            i = this.self( arguments )._indexFor( entry._hash, newCapacity );
                        entry._next = newTable[i];
                        newTable[i] = entry;
                        entry = next;
                    } while( entry !== null );
                }
            }
        },

        putAll: function (map) {
            var numKeyToBeAdded = map.size();
            if( numKeyToBeAdded === 0 ) {
                return;
            }

            if( numKeyToBeAdded > this._threshold ) {
                var targetCapacity = (numKeyToBeAdded / this._loadFactor + 1) | 0;
                if( targetCapacity > this.self( arguments ).MAXIMUM_CAPACITY ) {
                    targetCapacity = this.self( arguments ).MAXIMUM_CAPACITY;
                }

                var newCapacity = this._table.length;
                while( newCapacity < targetCapacity ) {
                    newCapacity <<= 1;
                }
                if( newCapacity > this._table.length ) {
                    this._resize( newCapacity );
                }
            }

            var iterator = map.entrySet().iterator();
            while( iterator.hasNext() ) {
                var entry = iterator.next();
                this.put( entry.getKey(), entry.getValue() );
            }
        },

        remove: function (key) {
            var entry = this._removeEntryForKey( key );
            return entry === null ? null : entry._value;
        },

        _removeEntryForKey: function (key) {
            var hash = (key === null) ? 0 : this.self( arguments )._hash( key.hashCode() ),
                i = this.self( arguments )._indexFor( hash, this._table.length ),
                prev = this._table[i],
                entry = prev;

            while( entry !== null ) {
                var next = entry._next,
                    /** @type jsava.lang.Object */
                        k;
                if( entry._hash === hash
                    && ( (k = entry._key) === key || ( key !== null && key.equals( k ) ) ) ) {
                    this._modCount++;
                    this._size--;
                    if( prev === entry ) {
                        this._table[i] = next;
                    } else {
                        prev._next = next;
                    }
                    entry._recordRemoval( this );
                    return entry;
                }
                prev = entry;
                entry = next;
            }

            return entry;
        },

        _removeMapping: function (obj) {
            if( obj === null || !qx.Class.implementsInterface( obj, jsava.util.Map.Entry ) ) {
                return null;
            }

            /** @implements jsava.util.Map.Entry */
            var entry = obj,
                key = entry.getKey(),
                hash = (key === null) ? 0 : this.self( arguments )._hash( key.hashCode() ),
                i = this.self( arguments )._indexFor( hash, this._table.length ),
                prev = this._table[i],
                e = prev;

            while( e !== null ) {
                var next = e._next;
                if( e._hash === hash && e.equals( entry ) ) {
                    this._modCount++;
                    this._size--;
                    if( prev === e ) {
                        this._table[i] = next;
                    } else {
                        prev._next = next;
                    }
                    e._recordRemoval( this );
                    return e;
                }
                prev = e;
                e = next;
            }

            return e;
        },

        clear: function () {
            this._modCount++;
            var table = this._table;
            for( var i = 0; i < table.length; i++ ) {
                table[i] = null;
            }
            this._size = 0;
        },

        containsValue: function (value) {
            if( value === null ) {
                return this.__containsNullValue();
            }

            var table = this._table;
            for( var i = 0; i < table.length; i++ ) {
                for( var entry = table[i]; entry !== null; entry = entry._next ) {
                    if( value.equals( entry._value ) ) {
                        return true;
                    }
                }
            }

            return false;
        },

        __containsNullValue: function () {
            var table = this._table;
            for( var i = 0; i < table.length; i++ ) {
                for( var entry = table[i]; entry !== null; entry = entry._next ) {
                    if( entry._value === null ) {
                        return true;
                    }
                }
            }

            return false;
        },

        clone: function () {
            /** @type jsava.util.HashMap */
            var result = null;
            try {
                result = this.base( arguments );
            } catch( e ) {
                if( !qx.Class.isSubClassOf( e.constructor, jsava.lang.CloneNotSupportedException ) ) {
                    throw e;
                }
            }

            result._table = jsava.JsavaUtils.emptyArrayOfGivenSize( this._table.length, null );
            result.__entrySet = null;
            result._modCount = 0;
            result._size = 0;
            result._init();
            result.__putAllForCreate( this );

            return result;
        },

        _addEntry: function (hash, key, value, bucketIndex) {
            var entry = this._table[bucketIndex];
            this._table[bucketIndex] = new (this.self( arguments ).Entry)( hash, key, value, entry );
            if( this._size++ >= this._threshold ) {
                this._resize( 2 * this._table.length );
            }
        },

        _createEntry: function (hash, key, value, bucketIndex) {
            var entry = this._table[bucketIndex];
            this._table[bucketIndex] = new (this.self( arguments ).Entry)( hash, key, value, entry );
            this._size++;
        },

        keySet: function () {
            var keySet = this._keySet;
            return keySet !== null ? keySet : ( this._keySet = new this.KeySet( this ) );
        },

        values: function () {
            var values = this._values;
            return values !== null ? values : ( this._values = new this.Values( this ) );
        },

        entrySet: function () {
            return this.__entrySet0();
        },

        __entrySet0: function () {
            var entrySet = this.__entrySet;
            return entrySet !== null ? entrySet : ( this.__entrySet = new this.EntrySet( this ) );
        },

        /** @private */
        HashIterator: qx.Class.define( 'jsava.util.HashMap.HashIterator', {
            extend: jsava.lang.Object,
            implement: [jsava.util.Iterator],

            type: 'abstract',

            /** @protected */
            construct: function (thisHashMap) {
                this.__thisHashMap = thisHashMap;
                this._expectedModCount = this.__thisHashMap._modCount;
                if( this.__thisHashMap._size > 0 ) {
                    var table = this.__thisHashMap._table;
                    while( this._index < table.length && ( this._next = table[this._index++] ) === null ) {
                        // do nothing
                    }
                }
            },

            members: {
                __thisHashMap: null,

                /** @type jsava.util.HashMap.Entry */
                _next: null,
                /** @type Number */
                _expectedModCount: 0,
                /** @type Number */
                _index: 0,
                /** @type jsava.util.HashMap.Entry */
                _current: null,

                hasNext: function () {
                    return this._next !== null;
                },

                _nextEntry: function () {
                    if( this.__thisHashMap._modCount !== this._expectedModCount ) {
                        throw new jsava.lang.ConcurrentModificationException();
                    }

                    var entry = this._next;
                    if( entry === null ) {
                        throw new jsava.lang.NoSuchElementException();
                    }

                    if( (this._next = entry._next) === null ) {
                        var table = this.__thisHashMap._table;
                        while( this._index < table.length && ( this._next = table[this._index++] ) === null ) {
                            // do nothing
                        }
                    }

                    this._current = entry;
                    return entry;
                },

                remove: function () {
                    if( this._current === null ) {
                        throw new jsava.lang.IllegalStateException();
                    }

                    if( this.__thisHashMap._modCount !== this._expectedModCount ) {
                        throw new jsava.lang.ConcurrentModificationException();
                    }

                    var key = this._current._key;
                    this._current = null;
                    this.__thisHashMap._removeEntryForKey( key );
                    this._expectedModCount = this.__thisHashMap._modCount;
                }
            }
        } ),

        _newKeyIterator: function () {
            return new this.KeyIterator( this );
        },

        _newValueIterator: function () {
            return new this.ValueIterator( this );
        },

        _newEntryIterator: function () {
            return new this.EntryIterator( this );
        },

        /** @private */
        ValueIterator: qx.Class.define( 'jsava.util.HashMap.ValueIterator', {
            extend: jsava.util.HashMap.HashIterator,

            construct: function (thisHashMap) {
                this.base( arguments, thisHashMap );
            },

            members: {
                next: function () {
                    return this._nextEntry()._value;
                }
            }
        } ),

        /** @private */
        KeyIterator: qx.Class.define( 'jsava.util.HashMap.KeyIterator', {
            extend: jsava.util.HashMap.HashIterator,

            construct: function (thisHashMap) {
                this.base( arguments, thisHashMap );
            },

            members: {
                next: function () {
                    return this._nextEntry().getKey();
                }
            }
        } ),

        /** @private */
        EntryIterator: qx.Class.define( 'jsava.util.HashMap.EntryIterator', {
            extend: jsava.util.HashMap.HashIterator,

            construct: function (thisHashMap) {
                this.base( arguments, thisHashMap );
            },

            members: {
                next: function () {
                    return this._nextEntry();
                }
            }
        } ),

        /** @private */
        KeySet: qx.Class.define( 'jsava.util.HashMap.KeySet', {
            extend: jsava.util.AbstractSet,

            construct: function (thisHashMap) {
                this.base( arguments );
                this.__thisHashMap = thisHashMap;
            },

            members: {
                __thisHashMap: null,

                iterator: function () {
                    return this.__thisHashMap._newKeyIterator();
                },

                size: function () {
                    return this.__thisHashMap._size;
                },

                contains: function (obj) {
                    return this.__thisHashMap.containsKey( obj );
                },

                remove: function (obj) {
                    return this.__thisHashMap._removeEntryForKey( obj ) !== null;
                },

                clear: function () {
                    this.__thisHashMap.clear();
                }
            }
        } ),

        /** @private */
        Values: qx.Class.define( 'jsava.util.HashMap.Values', {
            extend: jsava.util.AbstractCollection,

            construct: function (thisHashMap) {
                this.base( arguments );
                this.__thisHashMap = thisHashMap;
            },

            members: {
                __thisHashMap: null,

                iterator: function () {
                    return this.__thisHashMap._newValueIterator();
                },

                size: function () {
                    return this.__thisHashMap._size;
                },

                contains: function (obj) {
                    return this.__thisHashMap.containsValue( obj );
                },

                clear: function () {
                    this.__thisHashMap.clear();
                }
            }
        } ),

        /** @private */
        EntrySet: qx.Class.define( 'jsava.util.HashMap.EntrySet', {
            extend: jsava.util.AbstractSet,

            construct: function (thisHashMap) {
                this.base( arguments );
                this.__thisHashMap = thisHashMap;
            },

            members: {
                __thisHashMap: null,

                iterator: function () {
                    return this.__thisHashMap._newEntryIterator();
                },

                size: function () {
                    return this.__thisHashMap._size;
                },

                contains: function (obj) {
                    if( obj === null || !qx.Class.implementsInterface( obj, jsava.util.Map.Entry ) ) {
                        return false;
                    }

                    /** @implements jsava.util.Map.Entry */
                    var entry = obj,
                        candidate = this.__thisHashMap._getEntry( entry.getKey() );
                    return candidate !== null && candidate.equals( entry );
                },

                remove: function (obj) {
                    return this.__thisHashMap._removeMapping( obj ) !== null;
                },

                clear: function () {
                    this.__thisHashMap.clear();
                }
            }
        } )
    }
} );

嗯,有趣的方法..您是否考虑过尝试自动化方法?也就是说,在当前Java实现的源代码上运行Java到JavaScript的编译器?
Claudiu

对,对我来说,这是一个有趣的项目,有很多事情我不能简单地“复制”代码。我不知道Java到Java的编译器,尽管我相信它们存在。我不确定他们会如何翻译。我相当确定他们无论如何都不会产生高质量的代码。
IngoBürk2013年

哎呀 我当时在想Google Web Toolkit的编译器,但看来他们最终还是按照您在此处为核心库所做的那样来完成工作:“ GWT编译器支持绝大多数Java语言本身。GWT运行时库模拟了Java的相关子集。 Java运行时库。”。也许要看一下,看看其他人如何解决相同的问题!
Claudiu

是的 我确信Google的解决方案远远超出我的范围,但是话又说回来,我只是在找乐子。不幸的是,源代码似乎已被撤消(?),至少我无法浏览它,并且有趣的链接似乎已消失。太糟糕了,我很想看看。
IngoBürk13年

玩得开心是最好的学习方法=)。感谢您的分享
Claudiu

0

我执行的另一个地图。使用随机化器,“泛型”和“迭代器” =)

var HashMap = function (TKey, TValue) {
    var db = [];
    var keyType, valueType;

    (function () {
        keyType = TKey;
        valueType = TValue;
    })();

    var getIndexOfKey = function (key) {
        if (typeof key !== keyType)
            throw new Error('Type of key should be ' + keyType);
        for (var i = 0; i < db.length; i++) {
            if (db[i][0] == key)
                return i;
        }
        return -1;
    }

    this.add = function (key, value) {
        if (typeof key !== keyType) {
            throw new Error('Type of key should be ' + keyType);
        } else if (typeof value !== valueType) {
            throw new Error('Type of value should be ' + valueType);
        }
        var index = getIndexOfKey(key);
        if (index === -1)
            db.push([key, value]);
        else
            db[index][1] = value;
        return this;
    }

    this.get = function (key) {
        if (typeof key !== keyType || db.length === 0)
            return null;
        for (var i = 0; i < db.length; i++) {
            if (db[i][0] == key)
                return db[i][1];
        }
        return null;
    }

    this.size = function () {
        return db.length;
    }

    this.keys = function () {
        if (db.length === 0)
            return [];
        var result = [];
        for (var i = 0; i < db.length; i++) {
            result.push(db[i][0]);
        }
        return result;
    }

    this.values = function () {
        if (db.length === 0)
            return [];
        var result = [];
        for (var i = 0; i < db.length; i++) {
            result.push(db[i][1]);
        }
        return result;
    }

    this.randomize = function () {
        if (db.length === 0)
            return this;
        var currentIndex = db.length, temporaryValue, randomIndex;
        while (0 !== currentIndex) {
            randomIndex = Math.floor(Math.random() * currentIndex);
            currentIndex--;
            temporaryValue = db[currentIndex];
            db[currentIndex] = db[randomIndex];
            db[randomIndex] = temporaryValue;
        }
        return this;
    }

    this.iterate = function (callback) {
        if (db.length === 0)
            return false;
        for (var i = 0; i < db.length; i++) {
            callback(db[i][0], db[i][1]);
        }
        return true;
    }
}

例:

var a = new HashMap("string", "number");
a.add('test', 1132)
 .add('test14', 666)
 .add('1421test14', 12312666)
 .iterate(function (key, value) {console.log('a['+key+']='+value)});
/*
a[test]=1132
a[test14]=666
a[1421test14]=12312666 
*/
a.randomize();
/*
a[1421test14]=12312666
a[test]=1132
a[test14]=666
*/
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.