Explicación detallada de la implementación de la estructura de mapeo de mapas hash en JavaScript

El mapa hash generalmente se usa en JavaScript como un lugar simple para almacenar pares de valores clave. Sin embargo, el objeto no es un mapa de hash verdadero y puede causar problemas si se usa de manera incorrecta. Y JavaScript puede no proporcionar mapeo hash local (al menos no compatible con el navegador cruzado), hay una mejor manera de declarar las propiedades de los objetos.

Una simple implementación del mapa hash:

 var hashmap = {set: function (key, value) {this [key] = value}, get: function (key) {return this [key]}, contiene: function (key) {return this.get (key) == NULL? FALSE: true}, eliminar: function (key) {delete esta [clave]}}

Ejemplo de uso:

 Hashmap.set ("Nombre", "John Smith"); hashmap.set ("edad", 24); hashmap.get ("name"); // John Smith hashmap.contains ("título"); // falso hashmap.contains ("name"); // verdadero hashmap.remove ("edad");

Problemas en los miembros que declaran objetos

Este problema puede deberse al mecanismo de herencia de la cadena prototipo de objeto. Tome el método de tostración como ejemplo. Si el operador in se usa para determinar si el objeto existe:

 var map = {}; 'toString' en map; // verdadero

Porque el operador In buscará si el objeto existe de todos los prototipos. Para resolver este problema, puede usar el método de HaswnProperty para detectar si el objeto existe:

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

Este método funciona muy bien, pero si define una propiedad de HaswnProperty, puede ser problemático:

 var map = {}; map.hasownproperty = 'foo'; map.hasownproperty ('haownproperty'); // typeError

Una solución rápida para esto es usar objetos nativos.

 var map = {}; map.hasownproperty = 'foo'; {}. HasnownProperty.call (MAP, 'ASOWNProperty'); // verdadero

Este método no causará ningún problema. Cada vez que juzga si existen las propiedades en el objeto, debe filtrar los métodos en la cadena prototipo:

 var map = {}; var ha = {} .hasownproperty; for (var key en map) {if (has.call (map, key)) {// haz algo}}

Objeto desnudo

El truco para crear un mapa de hash real es resolver todos los objetos prototipo. Podemos lograr este efecto a través de Object.Create

 var obj = {}; // es equivalente a: var obj = object.create (object.prototype);

Además, este método le permite abandonar completamente el prototipo y usar directamente NULL para heredar.

 var map = object.create (null); map instanceOf Object; // falseObject.prototype.IsprototypeOf (MAP); // falseObject.getPrototypeOf (MAP); // nulo

Estos objetos desnudos (o diccionarios) son ideales como el mapa de hasp. Debido a que no habrá conflicto, resistirá cualquier tipo de conversión, como este causará errores.

 var map = object.create (null); map + ""; // typeError: no se puede convertir objeto a valor primitivo

No hay palabras reservadas aquí, está diseñada para el mapa hash, por ejemplo.

 var map = object.create (null); 'toString' en map; // FALSO

 var map = object.create (null); for (key var en map) {// haz algo}

Aparte de estas diferencias, no es diferente del almacenamiento de valor de clave de objeto general. El objeto se puede serializar, declararse prototipos y heredar, y el uso de variables de contexto es el mismo.

 var map = object.create (null); object.defineProperties (map, {'foo': {valor: 1, enumerable: true}, 'bar': {valor: 2, enumerable: falso}}); map.foo; // 1map ['bar']; // 2json.stringify (mapa); // {"foo": 1} {}. HasnownProperty.call (map, 'foo'); // true {}. PropertyIsenumerable.call (mapa, 'bar'); // FALSO

Incluso los métodos de detección de variables mencionados anteriormente también son aplicables.

 var map = object.create (null); typeOf map; // objeto {}. toString.call (map); // [objeto objeto] {}. valorf.call (map); // Objeto {}