Explicação detalhada da implementação da estrutura de mapeamento de mapas de hash em JavaScript

O mapa de hash é geralmente usado no JavaScript como um local simples para armazenar pares de valor-chave. No entanto, o objeto não é um mapa de hash verdadeiro e pode causar problemas se usado de forma inadequada. E o JavaScript pode não fornecer mapeamento local de hash (pelo menos não compatível com o navegador cruzado), existe uma maneira melhor de declarar propriedades do objeto.

Uma simples implementação do mapa de hash:

 var hashmap = {set: function (key, value) {this [key] = value}, get: function (key) {return this [key]}, contém: function (key) {return this.get (key) == null? false: true}, remover: function (key) {delete este [key]}}

Exemplo de uso:

 Hashmap.set ("Nome", "John Smith"); hashmap.set ("idade", 24); hashmap.get ("nome"); // John Smith Hashmap.contains ("title"); // false hashmap.contains ("nome"); // true hashmap.remove ("idade");

Questões em objetos declarando membros

Esse problema pode ser devido ao mecanismo de herança da cadeia de protótipo de objeto. Tome o método da tostragem como exemplo. Se o operador in for usado para determinar se o objeto existe:

 var map = {}; 'toString' no mapa; // verdadeiro

Porque o operador no IN procurará se o objeto existe de todos os protótipos. Para resolver esse problema, você pode usar o método HasownProperty para detectar se o objeto existe:

 var map = {}; map.HasownProperty ('ToString'); // false

Este método funciona muito bem, mas se você definir uma propriedade HistownProperty, poderá ser problemático:

 var map = {}; map.HasownProperty = 'Foo'; map.HasownProperty ('HasOwnsProperty'); // typeError

Uma solução rápida para isso é usar objetos nativos.

 var map = {}; map.HasownProperty = 'Foo'; {}. HasOwnProperty.Call (map, 'HasOwnProperty'); // verdadeiro

Este método não causará problemas. Toda vez que você julga se as propriedades do objeto existem, você deve filtrar os métodos na cadeia de protótipo:

 var map = {}; var has = {} .HasownProperty; para (var tecla no map) {if (has.call (map, key)) {// faça algo}}

Objeto nu

O truque para criar um mapa de hash real é resolver todos os objetos do protótipo. Podemos alcançar esse efeito através do objeto.Criar

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

Além disso, esse método permite abandonar completamente o protótipo e usar diretamente o NULL para herdar.

 var map = object.create (null); mapa instância do objeto; // falsebject.prototype.isprototypeof (map); // falseBject.getPrototypeof (map); // nulo

Esses objetos nus (ou dicionários) são ideais como mapa HASP. Como não haverá conflito, ele resistirá a qualquer tipo de conversão, como esse, causará erros.

 var map = object.create (nulo); map + ""; // TypeError: não é possível converter objeto em valor primitivo

Não há palavras reservadas aqui, ele foi projetado para mapa de hash, por exemplo.

 var map = object.create (null); 'toString' no mapa; // false

 var map = object.create (null); para (var tecla no mapa) {// faça algo}

Além dessas diferenças, não é diferente do armazenamento geral de valor-chave do objeto. O objeto pode ser serializado, protótipos declarados e herdados, e o uso de variáveis de contexto é o mesmo.

 var map = object.create (null); object.DefineProperties (map, {'foo': {value: 1, enumerável: true}, 'bar': {value: 2, enumerável: false}}); map.foo; // 1MAP ['bar']; // 2json.stringify (map); // {"Foo": 1} {}. HasownProperty.call (map, 'foo'); // true {}. Propertyisenumerable.call (map, 'bar'); // false

Mesmo os métodos de detecção variável mencionados acima também são aplicáveis.

 var map = object.create (nulo); tipo de mapa; // objeto {}. tostring.call (map); // [objeto objeto] {}. valueof.call (map); // objeto {}