Explication détaillée de la mise en œuvre de la structure de cartographie des cartes de hachage en javascript

La carte de hachage est généralement utilisée en JavaScript comme un endroit simple pour stocker les paires de valeurs clés. Cependant, l'objet n'est pas une vraie carte de hachage et peut potentiellement causer des problèmes s'il est mal utilisé. Et JavaScript peut ne pas fournir de mappage de hachage local (du moins pas compatible avec les navigateurs), il existe un meilleur moyen de déclarer les propriétés des objets.

Une simple implémentation de la carte de hachage:

 var hashmap = {set: function (key, value) {this [key] = value}, get: function (key) {return this [key]}, contient: function (key) {return this.get (key) == null? false: true}, supprimer: function (key) {delete this [key]}}}

Exemple d'utilisation:

 hashmap.set ("nom", "John Smith"); hashmap.set ("âge", 24); hashmap.get ("name"); // John Smith Hashmap.Contains ("Title"); // false hashmap.contains ("name"); // true hashmap.remove ("age");

Problèmes d'objet déclarant les membres

Ce problème peut être dû au mécanisme d'héritage de la chaîne prototype d'objet. Prenons l'exemple de la méthode TOSTRING. Si l'opérateur in est utilisé pour déterminer si l'objet existe:

 var map = {}; 'toString' dans map; // vrai

Parce que l'opérateur in cherchera si l'objet existe de tous les prototypes. Pour résoudre ce problème, vous pouvez utiliser la méthode HasownProperty pour détecter si l'objet existe:

 var map = {}; map.hasownproperty ('toString'); // FAUX

Cette méthode fonctionne très bien, mais si vous définissez une propriété HasownProperty, elle peut être gênante:

 var map = {}; map.hasownproperty = 'foo'; map.hasownproperty ('HasownProperty'); // TypeError

Une solution rapide à cela consiste à utiliser des objets natifs.

 var map = {}; map.hasownproperty = 'foo'; {}. Hasownproperty.call (map, 'HasownProperty'); // vrai

Cette méthode ne causera aucun problème. Chaque fois que vous jugez si les propriétés de l'objet existent, vous devez filtrer les méthodes dans la chaîne prototype:

 var map = {}; var a = {} .hasownproperty; for (var key in map) {if (has.call (map, key)) {// faire quelque chose}}

Objet nu

L'astuce pour créer une carte de hachage réelle consiste à résoudre tous les objets prototypes. Nous pouvons réaliser cet effet via objet.

 var obj = {}; // équivaut à: var obj = object.create (object.prototype);

De plus, cette méthode vous permet d'abandonner complètement le prototype et d'utiliser directement NULL pour hériter.

 var map = object.create (null); map instanceof objet; // FalseObject.prototype.isprototypeOf (MAP); // falseObject.getPrototypeOf (map); // nul

Ces objets nus (ou dictionnaires) sont idéaux comme carte HASP. Parce qu'il n'y aura pas de conflit, il résistera à toute conversion de type, comme cela entraînera des erreurs.

 var map = object.create (null); map + ""; // TypeError: Impossible de convertir l'objet en valeur primitive

Il n'y a pas de mots réservés ici, il est conçu pour la carte de hachage, par exemple.

 var map = object.create (null); 'toString' dans map; // FAUX

 var map = object.create (null); pour (clé var dans map) {// faire quelque chose}

En dehors de ces différences, il n'est pas différent du stockage général de la valeur de clé d'objet. L'objet peut être sérialisé, déclaré des prototypes et hérités, et l'utilisation des variables de contexte est la même.

 var map = object.create (null); object.defineproperties (map, {'foo': {value: 1, énumérable: true}, 'bar': {valeur: 2, énumérable: false}}); map.foo; // 1Map ['bar']; // 2json.stringify (map); // {"foo": 1} {}. HasownProperty.Call (map, 'foo'); // true {}. PropertyIsenuMable.Call (map, 'bar'); // FAUX

Même les méthodes de détection des variables mentionnées ci-dessus sont également applicables.

 var map = object.create (null); typeof map; // objet {}. toString.call (map); // [objet objet] {}. ValueOf.Call (map); // Objet {}