同等のJavaScriptハッシュマップ
アップデート3の この答え で明らかにされているように、この表記は：
var hash = {};
hash[X]
実際にはオブジェクトXをハッシュしません。実際にはXを文字列に変換し（それがオブジェクトの場合は.toString()、またはその他のさまざまなプリミティブ型用の組み込み変換を介して）、その文字列をハッシュせずに "hash"で検索します。オブジェクトの等価性もチェックされません - 2つの異なるオブジェクトが同じ文字列変換を持つ場合、それらはお互いを上書きするだけです。
これを考えると - JavaScriptのハッシュマップの効率的な実装はありますか？ （例えば、 javascript hashmap の2番目のGoogleの結果は、どんな演算に対しても_ 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によるインデックス付けを、メモリ割り当てを大幅に増やすことやオーバーフロー処理なしで制御できます。
もちろん、もしあなたが本当に「工業用ソリューション」を望むのであれば、key関数によって、そしてコンテナのすべての必要な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 。 Objects.cc および objects-inl.h で、適切な詳細を持つ NameDictionary および NameDictionaryShape を探します。
- Firefox / Gecko ： JSObject 、 NativeObject 、および PlainObject 、 jsobj.cpp および vm/NativeObject.cpp に関連する詳細があります。
彼らは衝突を処理しますか？
はい。上記を参照。等しくない文字列で衝突を見つけた場合は、ベンダにバグを報告することを躊躇しないでください。
それであなたの考えは何ですか？
オブジェクトをハッシュしたい場合は、それを一意にするものを見つけて、それをキーとして使用してください。実際のハッシュを計算したり、ハッシュテーブルをエミュレートしたりしないでください。すでに基礎となるJavaScriptオブジェクトによって効率的に処理されています。
JavaScriptのObjectでこのキーを使用すると、デフォルトのプロパティとの衝突の可能性を避けながら、組み込みのハッシュテーブルを利用できます。
始めるための例：
- オブジェクトに固有のユーザー名が含まれている場合は、それをキーとして使用してください。
- 一意の顧客番号が含まれている場合は、それをキーとして使用してください。
- SSNのような政府発行の固有の番号、またはパスポート番号が含まれていて、システムで重複が許可されていない場合は、それをキーとして使用してください。
- フィールドの組み合わせが固有のものである場合 - それをキーとして使用してください。
- 州の略語+運転免許証番号が優れた鍵になります。
- 国の略称+パスポート番号も優れた鍵です。
- フィールドに対する関数、またはオブジェクト全体は、一意の値を返すことができます - それをキーとして使用してください。
あなたの提案を使用し、ユーザー名を使用してすべてのオブジェクトをキャッシュしました。しかし、賢い人は "toString"と名付けられています。これは組み込みプロパティです。私は今どうすればいい？
明らかに、結果として得られるキーがラテン文字だけで構成されることがリモートでさえ可能な場合は、それについて何かするべきです。たとえば、デフォルトのプロパティ「#toString」、「#MarySmith」を使用して、先頭または末尾に非UnicodeのUnicode文字を追加して衝突を解除します。複合キーが使用されている場合は、何らかのラテン文字以外の区切り文字（ "name、city、state"）を使用してキーコンポーネントを区切ります。
一般的に、これは私たちが創造的でなければならない場所であり、与えられた制限（一意性、デフォルトプロパティとの潜在的な衝突）を持つ最も簡単なキーを選択します。
注意：一意のキーは定義によって衝突しませんが、潜在的なハッシュ衝突は基礎となるObjectによって処理されます。
なぜあなたは産業用ソリューションが好きではないのですか？
私見、最高のコードはまったくコードではありません：それはエラーがなく、メンテナンスも必要なく、理解しやすく、そして即座に実行されます。私が見た「JavaScriptのハッシュテーブル」はすべて100行以上のコードで、複数のオブジェクトを含んでいました。 dict[key] = valueと比較してください。
もう1つのポイント：JavaScriptとまったく同じ原始オブジェクトを使用して、すでに実装されているものを実装することで、低水準言語で書かれた原始オブジェクトのパフォーマンスを上回ることさえ可能ですか？
キーなしでオブジェクトをハッシュしたいのですが。
私達は幸運です：ECMAScript 6（2015年半ばのリリースを予定しています、その後広められるようにするために1〜2年をかけてください）は map および set を定義します。
定義から判断すると、オブジェクトのアドレスをキーとして使用できます。これにより、人工的なキーがなくてもオブジェクトは即座に区別されます。 OTOHは、2つの異なるが同一のオブジェクトですが、別個のものとしてマップされます。
_ mdn _ からの比較内訳
オブジェクトは、キーを値に設定し、それらの値を取得し、キーを削除し、何かがキーに格納されているかどうかを検出できるという点でMapsと似ています。このため（そして組み込みの代替手段がないため）、オブジェクトは歴史的にマップとして使用されてきました。ただし、特定の場合にMapを使用することを推奨する重要な違いがいくつかあります。
- オブジェクトのキーは文字列とシンボルですが、関数、オブジェクト、プリミティブなど、マップの任意の値にすることができます。
- Mapのキーは順序付けされていますが、objectに追加されたキーは順序付けられていません。したがって、それを反復処理すると、Mapオブジェクトは挿入順にキーを返します。
- オブジェクトのプロパティ数は手動で決定する必要がありますが、sizeプロパティを使用してMapのサイズを簡単に取得できます。
- Mapは反復可能なので直接反復することができますが、Objectを反復するには何らかの方法でキーを取得し、それらを反復する必要があります。
- Objectはプロトタイプを持っているので、注意しないとマップにデフォルトのキーが衝突する可能性があります。 ES5では、これはmap = Object.create（null）を使用してバイパスできますが、これはほとんど行われていません。
- キーペアの頻繁な追加と削除を含むシナリオでは、マップのパフォーマンスが向上することがあります。
問題の説明
JavaScriptには、一般的なmap type（連想配列または辞書とも呼ばれます）がなく、任意のキーで任意の値にアクセスできます。 JavaScriptの基本的なデータ構造はobjectです。これは文字列をキーとしてのみ受け付け、プロトタイプ継承、ゲッターとセッター、さらにいくつかのさらなるブードゥーのような特別な意味を持つ特別なタイプのマップです。
オブジェクトをマップとして使用する場合、キーはtoString()を介して文字列値に変換されるため、5と'5'が同じ値にマッピングされ、toString()メソッドがインデックス付けされた値に上書きされないすべてのオブジェクトが発生します。 '[object Object]'。 hasOwnProperty()をチェックしない場合は、意図せずにその継承されたプロパティにアクセスするかもしれません。
JavaScriptに組み込まれたarray typeは少し役に立ちません。JavaScript配列は連想配列ではなく、さらにいくつかの特別なプロパティを持つオブジェクトです。なぜそれらが地図として使えないのか知りたいのならば、 ここを見てください 。
ユージーンのソリューション
Eugene Lazutkinは、辞書オブジェクトのプロパティとして関連する値を調べるために使用できる一意の文字列を生成するためにカスタムハッシュ関数を使用するという基本的な考え方をすでに説明しました。オブジェクトは内部的にhash tablesとして実装されているので、これはおそらく最速の解決策でしょう。
- 注： ハッシュテーブル（hash mapsと呼ばれることもあります）は、バッキング配列と数値ハッシュ値によるルックアップを使用したマップの概念の特定の実装です。実行時環境では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()を変更することはvery悪い考えです）。 toString()が任意のオブジェクトに対して意味のある値を返すようにしたい場合は、Object.prototypeを修正しなければなりません。これは、一部の人々（私自身は含まれません）がverbotenを考慮します。
編集： 私のMapの実装の現在のバージョンは他のJavaScriptと同様に ここから入手できます 。
私はこの質問がかなり古くからあることを知っていますが、今日では外部ライブラリを使った本当に素晴らしい解決策がいくつかあります。
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"
あなたはオブジェクト/値のペアのいくつかの内部状態の対を保存する必要があるでしょう
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の答えに沿ったもう1つのアプローチは、何らかの理由ですべてのオブジェクトに一意の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オブジェクトを使ってください。
パフォーマンスがそれほど重要ではなく（キーの数が比較的少ないなど）、_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と比較すると、2つの問題があります：O(n)検索時間と非脆弱性（つまり、キーを解放するために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;
};
私のJavaScriptハッシュテーブルの実装を試してみてください： http://www.timdown.co.uk/jshashtable
キーオブジェクトのhashCode（）メソッドを探すか、Hashtableオブジェクトを作成するときにハッシュ関数を提供できます。
これはかなり堅牢なソリューションのように見えます： https://github.com/flesler/hashmap 。同一に見える関数やオブジェクトに対してもうまく機能します。それが使用する唯一のハックはそれを識別するためにオブジェクトに不明瞭なメンバを追加することです。あなたのプログラムがそのあいまいな変数（ hashid のようなもの）を上書きしないのであれば、問題ありません。
さらに別の解決策を追加する：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();
}
}
} )
}
} );
私によるもう一つの地図の実装。ランダマイザ、 'generics'、 'iterator' =）
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
*/