この回答の更新3で明らかにされているように、この表記は次のとおりです。

var hash = {};
hash[X]

実際にはオブジェクトをハッシュしませんX。実際には、単にX文字列に変換され（.toString()それがオブジェクトの場合、またはさまざまなプリミティブ型に対する他の組み込み変換によって）、その文字列をハッシュせずに " hash"で検索します。オブジェクトの等価性もチェックされません-2つの異なるオブジェクトが同じ文字列変換を持っている場合、それらは互いに上書きするだけです。

これを考えると、JavaScriptのハッシュマップの効率的な実装はありますか？（たとえば、2番目のGoogleの結果はjavascript hashmap、任意の操作に対してO（n）である実装を生成します。他のさまざまな結果は、同等の文字列表現を持つ異なるオブジェクトが互いに上書きするという事実を無視します。

自分でオブジェクトを手動でハッシュして、結果の文字列を通常の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エンコード、またはDojoX UUID。後者のソリューションは一意のキーを生成する可能性がありますが、特にオブジェクトの一意性を理解している場合は特に、個人的なコストでそれらを回避しようとします。

2014年の更新： 2008年に返答されたこの単純なソリューションには、さらに説明が必要です。アイデアをQ＆Aフォームで明確にしましょう。

あなたのソリューションには本当のハッシュがありません。それはどこにある？？？

JavaScriptは高水準言語です。その基本的なプリミティブ（Object）には、プロパティを保持するためのハッシュテーブルが含まれています。このハッシュテーブルは通常、効率を上げるために低水準言語で記述されています。文字列キーを持つ単純なオブジェクトを使用して、私たちは効率的に実装されたハッシュテーブルを使用します。

彼らがハッシュを使用していることをどうやって知っていますか？

キーでアドレス指定可能なオブジェクトのコレクションを保持するには、主に3つの方法があります。

• 順不同。この場合、キーでオブジェクトを取得するには、すべてのキーを調べて、オブジェクトが見つかったときに停止する必要があります。平均してn / 2の比較が行われます。
• 順序付けられました。
  • 例1：ソートされた配列—バイナリ検索を実行すると、平均して〜log2（n）の比較後にキーが見つかります。ずっといい。
  • 例＃2：ツリー。繰り返しますが、これは〜log（n）回の試行です。
• ハッシュ表。平均して一定の時間が必要です。比較：O（n）対O（log n）対O（1）。ブーム。

明らかに、JavaScriptオブジェクトは一般的なケースを処理するためにハッシュテーブルを何らかの形で使用します。

ブラウザベンダーは本当にハッシュテーブルを使用しますか???

本当に。

• Chrome / node.js / V8： JSObject。探し NameDictionaryと NameDictionaryShape関連で詳細をobjects.cc とオブジェクト-inl.h。
• Firefoxの/ ヤモリ： JSObjectを、 NativeObject、および PlainObject中の該当詳細を jsobj.cppおよび VM / NativeObject.cpp。

彼らは衝突を処理しますか？

はい。上記を参照。等しくない文字列の衝突を見つけた場合は、ベンダーにバグを報告することをためらわないでください。

だからあなたのアイデアは何ですか？

オブジェクトをハッシュしたい場合は、オブジェクトを一意にするものを見つけ、それをキーとして使用します。実際のハッシュを計算したり、ハッシュテーブルをエミュレートしたりしないでください。これは、基礎となるJavaScriptオブジェクトによってすでに効率的に処理されています。

JavaScriptでこのキーを使用Objectして、組み込みのハッシュテーブルを活用しながら、デフォルトプロパティとの衝突の可能性を回避します。

始めるための例：

• オブジェクトに一意のユーザー名が含まれている場合は、それをキーとして使用してください。
• 一意の顧客番号が含まれている場合は、それをキーとして使用してください。
  • SSNやパスポート番号などの政府発行の一意の番号が含まれていて、システムで重複が許可されていない場合は、キーとして使用してください。
• フィールドの組み合わせが一意である場合—キーとして使用します。
  • 州の略語+運転免許証番号は、優れたキーになります。
  • 国の略語+パスポート番号も優れたキーです。
• フィールドの一部の関数、またはオブジェクト全体は、一意の値を返すことができます—キーとして使用します。

私はあなたの提案を使用し、ユーザー名を使用してすべてのオブジェクトをキャッシュしました。しかし、賢明な人の中には、組み込みプロパティである「toString」という名前の人もいます。私は今どうすればいい？

明らかに、結果として得られるキーがラテン文字のみで構成される可能性さえある場合は、それについて何かをする必要があります。たとえば、デフォルトのプロパティである「#toString」、「＃MarySmith」と競合しないように、先頭または末尾にラテン語以外のUnicode文字を追加します。複合キーを使用する場合は、ラテン文字以外の区切り文字「name、city、state」を使用してキーコンポーネントを分離します。

一般に、ここは創造的でなければならない場所であり、特定の制限（一意性、デフォルトプロパティとの潜在的な衝突）がある最も簡単なキーを選択します。

注：一意のキーは定義上は衝突しませんが、潜在的なハッシュの衝突は基になるによって処理されObjectます。

なぜ産業用ソリューションが好きではないのですか？

私見、最高のコードはコードではありません：エラーがなく、メンテナンスが不要で、理解しやすく、瞬時に実行されます。私が見たすべての「JavaScriptのハッシュテーブル」は100行を超えるコードであり、複数のオブジェクトが関係していました。と比較してくださいdict[key] = value。

別のポイント：JavaScriptとまったく同じ原始オブジェクトを使用して、すでに実装されているものを実装することにより、低レベル言語で記述された原始オブジェクトのパフォーマンスを打ち負かすことさえ可能ですか？

キーなしでオブジェクトをハッシュしたいのですが！

幸運です：ECMAScript 6（2015年中頃のリリースを予定しており、普及するまでに1〜2年かかる）がmapと setを定義してい ます。

定義から判断すると、オブジェクトのアドレスをキーとして使用できるため、人工的なキーなしでオブジェクトを即座に区別できます。2つの異なるが同一のオブジェクトであるOTOHは、別個のものとしてマップされます。

MDNからの比較の内訳：

オブジェクトは、キーを値に設定し、それらの値を取得し、キーを削除し、何かがキーに格納されているかどうかを検出できるという点でマップに似ています。このため（および組み込みの代替手段がなかったため）、オブジェクトは歴史的にマップとして使用されてきました。ただし、特定の場合にマップの使用を推奨する重要な違いがあります。

• オブジェクトのキーは文字列とシンボルですが、関数、オブジェクト、プリミティブなど、マップの任意の値を使用できます。
• Mapのキーは順序付けされていますが、オブジェクトに追加されたキーは順序付けされていません。したがって、それを反復すると、Mapオブジェクトは挿入順にキーを返します。
• オブジェクトのプロパティの数は手動で決定する必要がありますが、サイズプロパティを使用するとマップのサイズを簡単に取得できます。
• Mapは反復可能であるため、直接反復できますが、オブジェクトを反復するには、何らかの方法でキーを取得し、それらを反復する必要があります。
• オブジェクトにはプロトタイプがあるため、注意しないとキーと衝突する可能性のあるデフォルトのキーがマップ内にあります。ES5以降、これはmap = Object.create（null）を使用してバイパスできますが、これが行われることはほとんどありません。
• キーペアを頻繁に追加および削除するシナリオでは、マップのパフォーマンスが向上する場合があります。

問題の説明

JavaScriptには、任意のキーによって任意の値にアクセスできる組み込みの一般的なマップタイプ（連想配列または辞書と呼ばれることもあります）がありません。JavaScriptの基本的なデータ構造はobjectです。これは、キーとして文字列のみを受け入れ、プロトタイプの継承、ゲッター、セッターなどの特別なセマンティクスを持つ、特別なタイプのマップです。

usingsがマップとしてオブジェクトをするときは、キーを介して、文字列値に変換されることを覚えておく必要がありtoString()、そのマッピングでの結果5と'5'同じ値と上書きされていないすべてのオブジェクトにtoString()でインデックス付けた値にする方法を'[object Object]'。また、チェックしないと、継承されたプロパティに思わずアクセスする可能性がありますhasOwnProperty()。

JavaScriptの組み込みの配列型は少し役に立ちません。JavaScript配列は連想配列ではなく、いくつかの特別なプロパティを持つオブジェクトにすぎません。マップとして使用できない理由については、こちらをご覧ください。

ユージーンのソリューション

Eugene Lazutkinは、カスタムハッシュ関数を使用して、関連する値を辞書オブジェクトのプロパティとして検索するために使用できる一意の文字列を生成する基本的な考え方をすでに説明しました。オブジェクトは内部的にハッシュテーブルとして実装されているため、これが最も高速な解決策になる可能性があります。

• 注：ハッシュテーブル（ハッシュマップと呼ばれることもあります）は、バッキング配列と数値ハッシュ値によるルックアップを使用したマップコンセプトの特定の実装です。ランタイム環境では、他の構造（検索ツリーやスキップリストなど）を使用してJavaScriptオブジェクトを実装できますが、オブジェクトは基本的なデータ構造であるため、十分に最適化する必要があります。

任意のオブジェクトの一意のハッシュ値を取得するための1つの可能性は、グローバルカウンタを使用して、ハッシュ値をオブジェクト自体（たとえば、という名前のプロパティ__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の利点は、ここから取得できます。

私はこの質問がかなり古いことを知っていますが、今日、外部ライブラリを使用したいくつかの本当に素晴らしい解決策があります。

• collections.js
• 不変

JavaScriptにもその言語が用意さMapれています。

• 地図

以下は、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  .....

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"

ES6 WeakMapまたはを使用できますMap。

• WeakMapsは、キーがオブジェクトであるキー/値マップです。

• Mapオブジェクトは単純なキー/値マップです。任意の値（オブジェクトとプリミティブ値の両方）をキーまたは値として使用できます。

どちらも広くサポートされていないことに注意してください。ただし、ES6 Shim（ネイティブES5またはES5 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）のどこかにあります。上記のEugeneの例は、実際のハッシュから予想されるあらゆる速度で動作するハッシュを取得する唯一の方法です。

更新：

Eugeneの答えに沿った別のアプローチは、何らかの方法ですべてのオブジェクトに一意のIDを添付することです。私のお気に入りのアプローチの1つは、Objectスーパークラスから継承された組み込みメソッドの1つを取り、それをカスタム関数パススルーで置き換え、その関数オブジェクトにプロパティをアタッチすることです。これを行うために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（）メソッドを「実装」する必要があります。

私は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")
}

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はMap / Hashmapを組み込みません。それは連想配列と呼ばれるべきです。

hash["X"]はと同じですがhash.X、文字列変数として「X」を使用できます。言い換えれば、hash[x]機能的にはeval("hash."+x.toString())

キーと値のマッピングではなく、object.propertiesに似ています。JavaScriptでより良いキー/値マッピングを探している場合は、Webで見つけられるMapオブジェクトを使用してください。

私のJavaScriptハッシュテーブルの実装を試してください：http : //www.timdown.co.uk/jshashtable

キーオブジェクトのhashCode（）メソッドを探します。または、Hashtableオブジェクトを作成するときにハッシュ関数を指定できます。

これは非常に堅牢なソリューションのように見えます：https : //github.com/flesler/hashmap。同じに見える関数やオブジェクトに対してもうまく機能します。それが使用する唯一のハックは、それを識別するためにオブジェクトに不明瞭なメンバーを追加することです。プログラムがそのあいまいな変数（hashidのようなもの）を上書きしない場合、あなたは黄金です。

パフォーマンスが重要でない場合（例えば、キーの量が比較的小さい）、あなたは（あなたまたはそうでないかもしれない）あなたを汚染したくないような追加フィールドを持つオブジェクト_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）検索時間と非脆弱性という2つの問題があります（つまり、キーを使用しdeleteたりclear、キーを離したりしないと、メモリリークが発生します）。

私のマップの実装は、クリストフの例から導き出されました：

使用例：

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;
};

さらに別のソリューションを追加する：これ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();
                }
            }
        } )
    }
} );