Équivalent JavaScript Hashmap
Comme indiqué clairement dans la mise à jour 3 sur cette réponse , cette notation:
_var hash = {};
hash[X]
_ne hache pas réellement l'objet X; en fait, il ne fait que convertir X en chaîne (via .toString() s'il s'agit d'un objet ou de toute autre conversion intégrée pour différents types primitifs), puis examine cette chaîne sans la hacher, dans "hash". L’égalité des objets n’est pas non plus vérifiée - si deux objets différents ont la même conversion de chaîne, ils s’écrasent.
Compte tenu de cela, existe-t-il des implémentations efficaces de hashmaps en javascript? (Par exemple, le deuxième résultat Google de javascript hashmap donne une implémentation qui est O(n) pour toute opération. Divers autres résultats ignorent le fait que différents objets avec les représentations de chaîne équivalentes se écrasent.
Pourquoi ne pas hacher manuellement vos objets et utiliser les chaînes résultantes comme clés pour un dictionnaire JavaScript classique? Après tout, vous êtes le mieux placé pour savoir ce qui rend vos objets uniques. C'est ce que je fais.
Exemple:
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;
De cette façon, vous pouvez contrôler l'indexation faite par JavaScript sans alourdir l'allocation de mémoire et gérer les débordements.
Bien sûr, si vous voulez vraiment la "solution de niveau industriel", vous pouvez construire une classe paramétrée par la fonction de clé et avec toutes les API nécessaires du conteneur, mais ... nous utilisons JavaScript, et en essayant d'être simple et léger, cette solution fonctionnelle est simple et rapide.
La fonction clé peut être aussi simple que de sélectionner les bons attributs de l'objet, par exemple une clé ou un ensemble de clés déjà uniques, une combinaison de clés uniques, ou aussi complexe que l'utilisation de hachages cryptographiques tels que dans Codage DojoX , ou ID DojoX . Alors que ces dernières solutions peuvent produire des clés uniques, j'essaie personnellement de les éviter à tout prix, surtout si je sais ce qui rend mes objets uniques.
Mise à jour en 2014: Répondu en 2008, cette solution simple nécessite toujours plus d'explications. Permettez-moi de clarifier l'idée dans un formulaire de questions-réponses.
Votre solution n'a pas de véritable hachage. Où est-ce???
JavaScript est un langage de haut niveau. Sa primitive de base ( Object ) comprend une table de hachage pour conserver les propriétés. Cette table de hachage est généralement écrite dans un langage de bas niveau pour plus d’efficacité. En utilisant un objet simple avec des clés de chaîne, nous utilisons une table de hachage efficacement mise en œuvre, sans aucun effort de notre part.
Comment savez-vous qu'ils utilisent le hachage?
Il existe trois manières principales de conserver une collection d'objets adressables par une clé:
- Non ordonné. Dans ce cas, pour récupérer un objet à l'aide de sa clé, nous devons passer en revue toutes les clés qui s'arrêtent lorsque nous le trouvons. En moyenne, il faudra n/2 comparaisons.
- Commandé.
- Exemple n ° 1: un tableau trié - lors d'une recherche binaire, nous trouverons notre clé après des comparaisons de ~ log2 (n) en moyenne. Beaucoup mieux.
- Exemple n ° 2: un arbre. Encore une fois ce sera ~ log (n) tentatives.
- Table de hachage. En moyenne, cela nécessite un temps constant. Comparez: O(n) vs. O (log n) vs. O (1). Boom.
Il est évident que les objets JavaScript utilisent des tables de hachage sous une forme quelconque pour traiter les cas généraux.
Les vendeurs de navigateurs utilisent-ils vraiment les tables de hachage ???
Vraiment.
- Chrome/node.js/ V8 : JSObject . Recherchez NameDictionary et NameDictionaryShape avec les détails pertinents dans objects.cc et objects-inl.h .
- Firefox/ Gecko : JSObject , NativeObject , et PlainObject avec les détails pertinents dans jsobj.cpp et vm/NativeObject.cpp .
Gèrent-ils les collisions?
Oui. Voir au dessus. Si vous rencontrez une collision sur des chaînes inégales, n'hésitez pas à signaler un bogue à un fournisseur.
Alors, quelle est votre idée?
Si vous souhaitez hacher un objet, recherchez ce qui le rend unique et utilisez-le comme clé. N'essayez pas de calculer un hachage réel ou d'émuler des tables de hachage - elles sont déjà gérées efficacement par l'objet JavaScript sous-jacent.
Utilisez cette clé avec JavaScript Object pour exploiter sa table de hachage intégrée tout en évitant les conflits éventuels avec les propriétés par défaut.
Exemples pour vous aider à démarrer:
- Si vos objets incluent un nom d'utilisateur unique, utilisez-le comme clé.
- S'il comporte un numéro de client unique, utilisez-le comme clé.
- S'il contient des numéros uniques émis par le gouvernement, tels qu'un numéro de sécurité sociale ou un numéro de passeport, et que votre système n'autorise pas les doublons, utilisez-le comme clé.
- Si une combinaison de champs est unique, utilisez-la comme clé.
- Abréviation d'état + numéro de permis de conduire fait une excellente clé.
- L'abréviation du pays + le numéro de passeport sont également une excellente clé.
- Certaines fonctions sur des champs, ou un objet entier, peuvent renvoyer une valeur unique - utilisez-la comme clé.
J'ai utilisé votre suggestion et mis en cache tous les objets à l'aide d'un nom d'utilisateur. Mais un type sage s'appelle "toString", ce qui est une propriété intégrée! Qu'est-ce que je devrais faire maintenant?
Évidemment, s'il est même possible que la clé résultante soit exclusivement composée de caractères latins, vous devriez faire quelque chose à ce sujet. Par exemple, ajoutez tout caractère Unicode non latin que vous préférez au début ou à la fin pour dissocier les propriétés par défaut: "#toString", "#MarySmith". Si une clé composite est utilisée, séparez les composants de clé à l'aide d'un type de délimiteur non latin: "nom, ville, état".
En général, c’est l’endroit où nous devons faire preuve de créativité et sélectionner les clés les plus faciles avec les limitations données (unicité, conflits potentiels avec les propriétés par défaut).
Remarque: les clés uniques ne sont pas en conflit par définition, tandis que les conflits de hachage potentiels seront gérés par le Object sous-jacent.
Pourquoi n'aimez-vous pas les solutions industrielles?
À mon humble avis, le meilleur code n’est pas du tout: il n’a pas d’erreur, il ne nécessite aucune maintenance, est facile à comprendre et s’exécute instantanément. Toutes les "tables de hachage en JavaScript" que j’ai vues étaient plus de 100 lignes de code et impliquaient plusieurs objets. Comparez-le avec: dict[key] = value.
Un autre point: est-il même possible de surpasser la performance d'un objet primordial écrit dans un langage de bas niveau, en utilisant JavaScript et les mêmes objets primordiaux pour implémenter ce qui est déjà implémenté?
Je veux toujours hacher mes objets sans aucune clé!
Nous avons de la chance: ECMAScript 6 (prévu pour la sortie de la mi-2015, environ un à deux ans plus tard) définit map et set .
À en juger par la définition, ils peuvent utiliser l'adresse de l'objet comme clé, ce qui permet de distinguer instantanément les objets sans clé artificielle. OTOH, deux objets différents mais identiques, seront mappés comme distincts.
Répartition de la comparaison de MDN :
Les objets sont similaires aux cartes, car ils vous permettent de définir des valeurs pour les clés, de les récupérer, de les supprimer et de détecter si quelque chose est stocké sur une clé. Pour cette raison (et parce qu'il n'y avait pas d'alternative intégrée), les objets ont été utilisés historiquement comme cartes; Cependant, il existe des différences importantes qui rendent l'utilisation d'une carte préférable dans certains cas:
- Les clés d'un objet sont des chaînes et des symboles, alors qu'elles peuvent être n'importe quelle valeur pour une carte, y compris les fonctions, les objets et toute primitive.
- Les clés dans Map sont ordonnées alors que les clés ajoutées à l'objet ne le sont pas. Ainsi, lors de son itération, un objet Map renvoie les clés dans l'ordre d'insertion.
- Vous pouvez facilement obtenir la taille d'une carte avec la propriété size, tandis que le nombre de propriétés dans un objet doit être déterminé manuellement.
- Une carte est un itératif et peut donc être directement itérée, alors que itérer sur un objet nécessite d’obtenir ses clés d’une certaine manière et de les itérer.
- Un objet a un prototype, il y a donc des clés par défaut dans la carte qui pourraient entrer en collision avec vos clés si vous ne faites pas attention. À partir de ES5, cela peut être contourné en utilisant map = Object.create (null), mais cela est rarement fait.
- Une carte peut mieux fonctionner dans des scénarios impliquant l'ajout et le retrait fréquents de paires de clés.
Description du problème
JavaScript n'a pas de type général map intégré (parfois appelé tableau associatif ou dictionnaire) permettant d'accéder à des valeurs arbitraires à l'aide de clés arbitraires. La structure de données fondamentale de JavaScript est le objet, un type de carte spécial qui n'accepte que les chaînes de caractères et possède une sémantique particulière, telle que l'héritage prototype, les accesseurs et les placeurs, ainsi que d'autres règles vaudou.
Lorsque vous utilisez des objets en tant que mappes, vous devez vous rappeler que la clé sera convertie en une valeur de chaîne via toString(), ce qui permet de mapper 5 et '5' avec la même valeur et tous les objets qui ne remplacez pas la méthode toString() par la valeur indexée par '[object Object]'. Vous pouvez également accéder involontairement à ses propriétés héritées si vous ne cochez pas hasOwnProperty().
Le type array intégré de JavaScript n'aide en rien: les tableaux JavaScript ne sont pas des tableaux associatifs, mais simplement des objets avec quelques propriétés spéciales supplémentaires. Si vous voulez savoir pourquoi elles ne peuvent pas être utilisées comme cartes, regardez ici .
La solution d'Eugène
Eugene Lazutkin a déjà décrit l'idée de base consistant à utiliser une fonction de hachage personnalisée pour générer des chaînes uniques pouvant être utilisées pour rechercher les valeurs associées en tant que propriétés d'un objet du dictionnaire. Ce sera probablement la solution la plus rapide, car les objets sont implémentés de manière interne en tant que tables de hachage.
- Remarque: Les tables de hachage (parfois appelées hash maps) constituent une implémentation particulière du concept de carte utilisant un tableau de sauvegarde et une recherche via valeurs de hachage numériques. L'environnement d'exécution peut utiliser d'autres structures (telles que arbres de recherche ou ignorer les listes) pour implémenter des objets JavaScript, mais comme ces objets constituent la structure de données fondamentale, ils doivent être suffisamment optimisés.
Pour obtenir une valeur de hachage unique pour les objets arbitraires, une possibilité consiste à utiliser un compteur global et à mettre en cache la valeur de hachage dans l'objet lui-même (par exemple, dans une propriété nommée __hash).
Une fonction de hachage qui fait cela est et fonctionne pour les valeurs et objets primitifs est:
function hash(value) {
return (typeof value) + ' ' + (value instanceof Object ?
(value.__hash || (value.__hash = ++arguments.callee.current)) :
value.toString());
}
hash.current = 0;
Cette fonction peut être utilisée comme décrit par Eugene. Pour plus de commodité, nous allons l’envelopper dans une classe Map.
Ma mise en œuvre Map
L'implémentation suivante stockera en outre les paires clé-valeur dans une liste doublement liée afin de permettre une itération rapide sur les clés et les valeurs. Pour fournir votre propre fonction de hachage, vous pouvez écraser la méthode hash() de l'instance après la création.
// 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;
};
Exemple
Le script suivant
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());
génère cette sortie:
string spam : eggs
string foo : baz
object 1 : an object
object 2 : another object
number 5 : five again
string 5 : another five
Autres considérations
PEZ a suggéré d’écraser la méthode toString(), probablement avec notre fonction de hachage. Ce n'est pas faisable car cela ne fonctionne pas pour les valeurs primitives (changer toString() pour les primitives est une très mauvaise idée). Si nous voulons que toString() renvoie des valeurs significatives pour des objets arbitraires, nous devons modifier Object.prototype, ce que certaines personnes (moi-même non inclus) considèrent verboten.
Edit: La version actuelle de mon implémentation de Map ainsi que d'autres goodies JavaScript peut être obtenue ici .
Je sais que cette question est assez ancienne, mais il existe actuellement de très bonnes solutions avec des bibliothèques externes.
JavaScript a également son langage fourni Map ainsi.
Voici un moyen simple et pratique d’utiliser quelque chose de similaire à la carte 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
}
Et pour obtenir la valeur:
alert( map['map_name_1'] ); // fives the value of map_value_1
...... etc .....
Vous pouvez utiliser ES6 WeakMap ou Map :
Les cartes faibles sont des cartes clé/valeur dans lesquelles les clés sont des objets.
Les objets
Mapsont de simples cartes clé/valeur. Toute valeur (à la fois des objets et des valeurs primitives) peut être utilisée comme clé ou comme valeur.
Sachez qu’aucun d’eux n’est largement supporté, mais vous pouvez utiliser ES6 Shim (nécessite l’ES5 natif ou ES5 Shim ) pour supporter Map, mais pas WeakMap ( , voir pourquoi ).
Selon la norme ECMAScript 2015 (ES6), javascript est implémenté dans Map. En savoir plus sur ce qui pourrait être trouvé ici
Utilisation de base:
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"
Vous devez stocker dans certains couplets d'état internes des paires objet/valeur
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];
}
}
Et utilisez-le comme tel:
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));
Bien sûr, cette implémentation est également quelque part dans les lignes de O (n). Les exemples d'Eugene ci-dessus sont le seul moyen d'obtenir un hachage qui fonctionne à toute vitesse que vous attendez d'un vrai hachage.
Mise à jour:
Une autre approche, dans le sens de la réponse d'Eugene, consiste à associer en quelque sorte un identifiant unique à tous les objets. Une de mes approches préférées consiste à prendre l’une des méthodes intégrées héritées de la super-classe Object, à la remplacer par une fonction personnalisée passthrough et à associer des propriétés à cet objet fonction. Si vous deviez réécrire ma méthode HashMap pour ce faire, cela ressemblerait à ceci:
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];
}
Cette version ne semble être que légèrement plus rapide, mais en théorie, elle le sera beaucoup plus rapidement pour les grands ensembles de données.
Malheureusement, aucune des réponses ci-dessus n'était bonne pour mon cas: différents objets de clé peuvent avoir le même code de hachage. J'ai donc écrit une version simple de HashMap, semblable à Java:
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;
}
Remarque: les objets de clé doivent "implémenter" les méthodes hashCode () et equals ().
J'ai implémenté un JavaScript HashMap dont le code peut être obtenu à partir de http://github.com/lambder/HashMapJS/tree/master
Voici le code:
/*
=====================================================================
@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")
}
Dans ECMA6, vous pouvez utiliser WeakMap
Exemple:
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
Mais:
Because of references being weak, WeakMap keys are not enumerable (i.e. there is no method giving you a list of the keys).
Javascript ne fait pas partie de Map/hashmap. Il devrait être appelé tableau associatif .
hash["X"] est égal à hash.X, mais autorise "X" en tant que variable chaîne. En d'autres termes, hash[x] est fonctionnellement égal à eval("hash."+x.toString())
Il ressemble plus à object.properties qu'à un mappage clé-valeur. Si vous recherchez une meilleure correspondance clé/valeur en Javascript, veuillez utiliser l'objet Carte que vous pouvez trouver sur le Web.
Si les performances ne sont pas critiques (par exemple, le nombre de clés est relativement faible) et que vous ne souhaitez pas polluer vos objets (ou peut-être pas vos objets) avec des champs supplémentaires tels que __hash_, __id_, etc., alors vous pouvez utiliser le fait que Array.prototype.indexOf utilise une égalité stricte. Voici une implémentation simple:
_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;
})();
_Exemple d'utilisation:
_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.
_Comparé à ES6 WeakMap, il a deux problèmes: O(n) le temps de recherche et la non faiblesse (c’est-à-dire que cela provoquera une fuite de mémoire si vous n’utilisez pas delete ou clear à relâcher les clés).
Ma mise en œuvre de carte, dérivée de l'exemple de Christoph:
Exemple d'utilisation:
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;
};
Essayez mon implémentation de la table de hachage JavaScript: http://www.timdown.co.uk/jshashtable
Il recherche une méthode hashCode () d'objets clés ou vous pouvez fournir une fonction de hachage lors de la création d'un objet Hashtable.
Cela ressemble à une solution assez robuste: https://github.com/flesler/hashmap . Cela fonctionnera même bien pour les fonctions et les objets qui semblent identiques. Le seul piratage utilisé consiste à ajouter un membre obscur à un objet pour l'identifier. Si votre programme n'écrase pas cette variable obscure (quelque chose comme hashid ), vous êtes en or.
Ajoutant encore une autre solution: HashMap est à peu près la première classe que j’ai portée de Java à Javascript. Vous pourriez dire qu'il y a beaucoup de temps système, mais l'implémentation correspond presque à 100% à celle de Java et inclut toutes les interfaces et les sous-classes.
Le projet peut être trouvé ici: https://github.com/Airblader/jsava J'attacherai également le code source (actuel) de la classe HashMap, mais comme indiqué, il dépend également du super class etc. Le cadre OOP utilisé est qooxdoo.
Edit: Veuillez noter que ce code est déjà obsolète et se référer au projet github pour le travail en cours. Au moment d'écrire ceci, il y a aussi une implémentation 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();
}
}
} )
}
} );
Encore une autre implémentation de carte par moi. Avec randomizer, 'génériques' et '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;
}
}
Exemple:
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
*/