Em JavaScript, um Map é um objeto embutido que armazena pares chave-valor, semelhante a um objeto. No entanto, ele difere dos objetos JavaScript padrão por permitir chaves de qualquer tipo, incluindo objetos e funções. Uma WeakMap é uma coleção de pares chave-valor, semelhante a uma Map, mas usa referências fracas para suas chaves. As chaves devem ser objetos, enquanto os valores podem ser de qualquer tipo. Pense na relação entre um WeakMap e um Map como semelhante à relação entre um WeakSet e um Set, como você aprendeu na lição anterior. Para criar um Map, você usa o construtor Map() precedido pela palavra-chave new:

const myFirstMap = new Map();

Você pode inicializar o Map com valores:

const myTreesMap = new Map([
 [{ type: 'deciduous' }, 'Maple tree'],
 [['forest', 'grove'], 'Pine tree'],
 [42, 'Oak tree'],
 [true, 'Birch tree'],
 [function() { return 'I am a function key'; }, 'Willow tree'],
]);

Se você não inicializou o Map com valores, pode usar o método set() para adicioná-los:

const myTreesMap = new Map();
myTreesMap.set({ type: 'deciduous' }, 'Maple tree');
myTreesMap.set([1, 2], 'Pine tree');
myTreesMap.set(42, 'Oak tree');
myTreesMap.set(true, 'Birch tree');
myTreesMap.set(function() { return "I'm a function key"; }, 'Willow tree');

console.log(myTreesMap);

Aqui está como um Map aparece no console:

/*
Map(5) {{…} => 'Maple tree', Array(2) => 'Pine tree', 42 => 'Oak tree', true => 'Birch tree', ƒ => 'Willow tree'}
  [[Entries]]
    0:{Object => "Maple tree"}
      key: {type: 'deciduous'}
      value: "Maple tree"
    1:{Array(2) => "Pine tree"}
      key: (2)
      value: "Pine tree"
    2:{42 => "Oak tree"}
      key: 42
      value: "Oak tree"
    3:{true => "Birch tree"}
      key: true
      value: "Birch tree"
    4:{function () { return "I'm a function key"; } => "Willow tree"}
      key: f ()
      value: "Willow tree"
    size: 5
    [[Prototype]]: Map
*/

Outros métodos que você pode usar para trabalhar com um Map são:

• get(key) para recuperar o valor associado à key especificada.
• has(key) para verificar se uma key existe no Map.
• delete(key) para remover um par chave-valor do Map.
• clear() para remover todos os pares chave-valor.
• entries() para verificar as entradas do Map (ele retorna as entradas em um MapIterator).
• forEach() para percorrer as entradas do Map.
• size para indicar o número de pares chave-valor no Map.

Existe um construtor WeakMap() que você pode usar para criar um WeakMap:

const myFirstWeakMap = new WeakMap();

Os métodos set(), get(), has() e delete() estão todos disponíveis para uso com um WeakMap também. Por exemplo, aqui está como você pode atribuir itens ao Map com o método set():

const myTreeWeakMap = new WeakMap();

myTreeWeakMap.set({ id: 1 }, 'Maple tree');
myTreeWeakMap.set({ id: 2 }, 'Pine tree');
myTreeWeakMap.set({ id: 3 }, 'Oak tree');
myTreeWeakMap.set({ id: 4 }, 'Birch tree');
myTreeWeakMap.set({ id: 5 }, 'Willow tree');

console.log(myTreeWeakMap);

Veja como um WeakMap aparece no console:

/*
WeakMap {{…} => 'Willow tree', {…} => 'Maple tree', {…} => 'Pine tree', {…} => 'Oak tree'}
  [[Entries]]
    No properties
  [[Prototype]]: WeakMap
*/

Aqui estão as diferenças entre um Map e um WeakMap: | Feature | Map | WeakMap | | --- | --- | --- | | Key Type | Keys can be of any data type, including strings, numbers, objects, or even functions. | Keys must be objects. | | Use Case | Use a Map when you need to associate data with any type of key. | Use a WeakMap when you only need to associate data with objects. | | Iteration | You can loop through a Map using forEach(), keys(), values(), or entries(). | A WeakMap is not iterable. | | Size Property | Map has a size property to get the number of key-value pairs. | WeakMap does not have a size property. | Na tabela acima, você pode ver as diferenças resumidas incluindo o tipo de chave, caso de uso, iteração e propriedade size. Por favor, reserve um momento para ler o conteúdo desta tabela para saber mais sobre as diferenças deles.