path: root/files/pt-br/web/javascript/reference/global_objects/map/index.html

---
title: Map
slug: Web/JavaScript/Reference/Global_Objects/Map
tags:
  - ECMAScript 2015
  - JavaScript
  - Map
  - Mapa
translation_of: Web/JavaScript/Reference/Global_Objects/Map
---
<div>{{JSRef}}</div>

<p>O objeto <strong><code>Map</code></strong> é um mapa simples de chave/valor. Qualquer valor (objeto e {{Glossary("Primitive", "valores primitivos")}}) pode ser usado como uma chave ou um valor.</p>

<h2 id="Sintaxe">Sintaxe</h2>

<pre class="syntaxbox notranslate"><code>new Map([iterable])
</code></pre>

<h3 id="Parâmetros">Parâmetros</h3>

<dl>
 <dt><code>iterable</code></dt>
 <dd>
 <p><code>Iterable</code> é um Array ou outro objeto iterável cujos elementos são pares de chave-valor (2-element Arrays). Cada par de chave-valor é adicionado ao novo Map. <code>null</code> é tratado como <code>undefined</code>.</p>
 </dd>
</dl>

<h2 id="Descrição">Descrição</h2>

<p>Um objeto Map itera seus elementos em ordem de inserção — um loop {{jsxref("Statements/for...of", "for...of")}} retorna um array de <code>[chave, valor]</code> para cada iteração.</p>

<p>Deve-se notar que um Map que é um mapa de um objeto, especialmente, um dicionário de dicionários somente irá mapear apenas para a ordem de inserção -- que é aleatória e não ordenada.</p>

<h3 id="Igualidade_de_valores">Igualidade de valores</h3>

<p>A igualdade das chaves é baseada no algoritmo "SameValueZero" (mesmo valor): <code>NaN</code> é considerado igual à <code>NaN</code> (mesmo que <code>NaN !== NaN</code>) e todos os outros valores são considerados iguals de acordo com a semantica do operador ===. Em versões anteriores do rascunho ECMAScript 2015 draft <code>-0</code> and <code>+0</code> eram considerados diferentes (mesmo que <code>-0 === +0</code>), isto foi trocado em versões posteriores e foi aplicado no Gecko 29 {{geckoRelease("29")}} ({{bug("952870")}}) e em uma<a href="https://code.google.com/p/v8/issues/detail?id=3069"> build recente nightly do Chrome</a>.</p>

<h3 id="Objetos_e_mapas_comparados">Objetos e mapas comparados</h3>

<p>{{jsxref("Object", "Objects")}} são similares a Maps onde ambos deixam adicionar chaves para valores, recuperar estes valores, apagar chaves, e detectar quando algo foi adicionado em uma chave. Por causa disso (e porque não existem alternativas pré-construidas), <code>Objects</code> historicamente foram usados como <code>Maps</code>; no entanto, existem diferenças importantes entre <code>Objects</code> e <code>Maps</code> que fazem o uso do Map melhor:</p>

<ul>
 <li>Um <code>Object</code> tem um prototype, então existem chaves padrão no mapa. Isto pode ser evitado usando um Map<code> = Object.create(null)</code> desde ES5, mas raramente é feito.</li>
 <li>As chaves de um <code>Object</code> são {{jsxref("String", "Strings")}} e {{jsxref("Symbol", "Symbols")}}, porém elas podem ser qualquer valor em um <code>Map</code>.</li>
 <li>Você pode obter o tamanho de um  <code>Map</code> facilmente enquanto em um <code>Object </code>é necessário ter este controle manualmente.</li>
</ul>

<p>Isto não significa que você deve usar <code>Map</code>s em todo lugar, objetos ainda serão usados na maioria dos casos. Instancias de <code>Map</code> são úteis somente para coleções, e você deve considerar adaptar seu codigo onde você usou objetos para isto anteriormente. Objects devem ser usados como registros, com campos e métodos.<br>
 Se você não tem certeza qual usar, pergunte-se as seguintes questões:</p>

<ul>
 <li>As keys são desconhecidas até o tempo de execução, você precisa procurá-las dinamicamente?</li>
 <li>Todos os valores sempre serão do mesmo tipo, e podem ser usados de forma intercambiável?</li>
 <li>Você precisa de keys que não são strings?</li>
 <li>Os pares key-value são adicionados ou removidos frequentemente?</li>
 <li>Você tem uma quantidade de pares key-value arbitrária (de troca fácil) ?</li>
 <li>A coleção é iterada?</li>
</ul>

<p>Se você respondeu "sim" em qualquer uma dessas questões, é um sinal de que você quer utilizar um  <code>Map</code>. Se ao invés disto você tem um numero fixo de keys, trabalhe eles individualmente, e faça diferenciação entre o uso deles, você quer um objeto.</p>

<h2 id="Propriedades">Propriedades</h2>

<dl>
 <dt><code>Map.length</code></dt>
 <dd>O tamanho do mapa é 0.</dd>
 <dt>{{jsxref("Map.@@species", "get Map[@@species]")}}</dt>
 <dd>A função construtora que é usada para criar objetos derivados.</dd>
 <dt>{{jsxref("Map.prototype")}}</dt>
 <dd>Representa o prototype para o construtor de <code>Map</code>. Permite a adição de propriedades para todos os objetos <code>Map</code>.</dd>
</dl>

<h2 id="Instâncias_de_Map">Instâncias de <code>Map</code></h2>

<p>Todas as instancias de <code>Map</code> herdam de {{jsxref("Map.prototype")}}.</p>

<h3 id="Propriedades_2">Propriedades</h3>

<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Map/prototype','Properties')}}</p>

<h3 id="Métodos">Métodos</h3>

<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Map/prototype','Methods')}}</p>

<h2 id="Exemplos">Exemplos</h2>

<h3 id="Usando_o_objeto_Map">Usando o objeto <code>Map</code></h3>

<pre class="brush: js notranslate">var myMap = new Map();

var keyString = "uma string",
    keyObj = {},
    keyFunc = function () {};

// configurando os valores
myMap.set(keyString, "valor associado com 'uma string'");
myMap.set(keyObj, "valor associado com keyObj");
myMap.set(keyFunc, "valor associado com keyFunc");

myMap.size; // 3

// obtendo os valores
myMap.get(keyString);    // "valor associado com 'uma string'"
myMap.get(keyObj);       // "valor associado com keyObj"
myMap.get(keyFunc);      // "valor associado com keyFunc"

myMap.get("uma string"); // "valor associado com 'uma string'"
                         // pois keyString === 'uma string'
myMap.get({});           // undefined, pois keyObj !== {}
myMap.get(function() {}) // undefined, pois keyFunc !== function () {}
</pre>

<h3 id="Usando_NaN_como_Map_keys">Usando <code>NaN</code> como <code>Map</code> keys</h3>

<p><code>NaN</code> pode também ser usado como key. Mesmo que <code>NaN</code> não seja igual a ele mesmo (<code>NaN !== NaN</code>)  é true, o seguinte exemplo funciona, porquê <code>NaN</code>s são indistinguíveis uma para o outro:</p>

<pre class="brush: js notranslate">var myMap = new Map();
myMap.set(NaN, "not a number");

myMap.get(NaN); // "not a number"

var otherNaN = Number("foo");
myMap.get(otherNaN); // "not a number"
</pre>

<h3 id="Iterando_Maps_com_for..of">Iterando <code>Maps</code> com <code>for..of</code></h3>

<p>Maps podem ser iterados usando um <code>for..of</code> :</p>

<pre class="brush: js notranslate">var myMap = new Map();
myMap.set(0, "zero");
myMap.set(1, "um");
for (var [key, value] of myMap) {
  console.log(key + " = " + value);
}
// 0 = zero
// 1 = um

for (var key of myMap.keys()) {
  console.log(key);
}
// 0
// 1

for (var value of myMap.values()) {
  console.log(value);
}
// zero
// um

for (var [key, value] of myMap.entries()) {
  console.log(key + " = " + value);
}
// 0 = zero
// 1 = um
</pre>

<h3 id="Iterando_Maps_com_forEach">Iterando <code>Maps</code> com <code>forEach()</code></h3>

<p>Maps podem ser iterados usando um <code>forEach()</code>:</p>

<pre class="brush: js notranslate">myMap.forEach(function(value, key) {
  console.log(key + " = " + value);
}, myMap)
// Mostrará 2 logs; o primeiro com "0 = zero" e o segundo com "1 = um"
</pre>

<h3 id="Relação_com_objetos_Array">Relação com objetos <code>Array</code></h3>

<pre class="brush: js notranslate">var kvArray = [["key1", "value1"], ["key2", "value2"]];

// Utiliza o construtor padrão de Map para converter um Array de 2 dimensões de chave-valor Array em um mapa
var myMap = new Map(kvArray);

myMap.get("key1"); // retorna "value1"

// Utiliza Array.from para converter um mapa em um Array de 2 dimensões de chave-valor
console.log(Array.from(myMap)) // Mostrará exatamente o mesmo Array que kvArray

// Uma forma mais sucinta de realizar a mesma conversão com o operador spread
console.log([...myMap]);

// Ou usa o operador spread nas chaves ou valores para o iterador pegar
// um array com somente as chaves ou valores
console.log([...myMap.keys()]); // Mostrará ["key1", "key2"]
</pre>

<h2 id="Especificações">Especificações</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Especificação</th>
   <th scope="col">Status</th>
   <th scope="col">Comentário</th>
  </tr>
  <tr>
   <td>{{SpecName('ES6', '#sec-map-objects', 'Map')}}</td>
   <td>{{Spec2('ES6')}}</td>
   <td>Definição inicial.</td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-map-objects', 'Map')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>

<p>{{Compat("javascript.builtins.Map")}}</p>

<p>[1] Começando com Chrome 31, a feature ficou disponível sob modificação de configurações. Em <code>chrome://flags</code>, ative a entrada activate “Enable Experimental JavaScript”.</p>

<h2 id="Ver_também">Ver também</h2>

<ul>
 <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=697479">Map and Set bug at Mozilla</a></li>
 <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:simple_maps_and_sets">ECMAScript Harmony proposal</a></li>
 <li>{{jsxref("Set")}}</li>
 <li>{{jsxref("WeakMap")}}</li>
 <li>{{jsxref("WeakSet")}}</li>
</ul>