path: root/files/pt-br/web/javascript/data_structures/index.html

---
title: Estrutura de dados do Javascript
slug: Web/JavaScript/Data_structures
tags:
  - Iniciante
  - JavaScript
  - Tipos
translation_of: Web/JavaScript/Data_structures
---
<div>{{jsSidebar("More")}}</div>

<p>Todas as linguagens de programação têm sua própria estrutura de dados embutida, mas essa estrutura frequentemente difere uma da outra. Este artigo busca listar os tipos de dados disponíveis na linguagem JavaScript e que propriedades eles possuem. Quando possível, comparações com outras linguagens serão apresentadas.</p>

<h2 id="Tipagem_Dinâmica">Tipagem Dinâmica</h2>

<p>JavaScript é uma linguagem de tipagem <em>dinâmica</em>. Isso significa que você não necessita declarar o tipo de uma variável antes de sua atribuição. O tipo será automaticamente determinado quando o programa for processado. Isso também significa que você pode reatribuir uma mesma variável com um tipo diferente:</p>

<pre class="brush: js notranslate">var foo = 42;    // foo é um <em>Number</em> agora
foo     = "bar"; // foo é um <em>String</em> agora
foo     = true;  // foo é um <em>Boolean</em> agora
</pre>

<h2 id="Tipos_de_Dados">Tipos de Dados</h2>

<p>A última versão ECMAScript define sete tipos de dados:</p>

<ul>
 <li>Sete tipos de dados são:  {{Glossary("Primitive", "primitives")}}:
  <ul>
   <li>{{Glossary("Boolean")}}</li>
   <li>{{Glossary("Null")}}</li>
   <li>{{Glossary("Undefined")}}</li>
   <li>{{Glossary("Number")}}</li>
   <li>{{Glossary("BigInt")}}</li>
   <li>{{Glossary("String")}}</li>
   <li>{{Glossary("Symbol")}}</li>
  </ul>
 </li>
 <li>e {{Glossary("Object")}}</li>
</ul>

<h2 id="Valores_Primitivos">Valores Primitivos</h2>

<p>Todos os tipos, com a exceção de objetos, definem valores imutáveis (valores que são incapazes de mudar). Por exemplo e diferentemente da linguagem C, Strings são imutáveis. Nós nos referimos a valores desse tipo como "valores primitivos".</p>

<h3 id="Tipo_Boolean">Tipo "Boolean"</h3>

<p>Boolean representa uma entidade lógica e pode ter dois valores: verdadeiro<code>(true)</code> ou falso<code>(false)</code>.</p>

<h3 id="Tipo_Null">Tipo "Null"</h3>

<p>O tipo Null tem exatamente um valor: <code>null</code>(nulo). Veja {{jsxref("null")}} e {{Glossary("Null")}} para mais detalhes.</p>

<h3 id="Tipo_Undefined">Tipo "Undefined"</h3>

<p>Uma variável que não foi atribuída a um valor específico, assume o valor <code><em>undefined</em></code>(indefinido). Veja {{jsxref("undefined")}} e {{Glossary("Undefined")}} para mais detalhes.</p>

<h3 id="Tipo_Number">Tipo "Number"</h3>

<p>De acordo com os padrões ECMAScript, existe somente um tipo numérico<em>. </em>O <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">double-precision 64-bit binary format IEEE 754 value</a> (número entre -(2<sup>53</sup> -1) e 2<sup>53</sup> -1). <strong>Não existe um tipo específico para inteiros</strong>. Além de poderem representar números de ponto-flutuante, o tipo <em>number</em> possui três valores simbólicos: <code>+Infinity</code>, <code>-Infinity</code>, e <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a> (não numérico).</p>

<p>Para verificar o maior ou o menor valor disponível dentro de +/-<code>Infinity</code>, você pode usar as constantes {{jsxref("Number.MAX_VALUE")}} ou {{jsxref("Number.MIN_VALUE")}}, e a partir do ECMAScript 6, você também consegue verificar se um número está dentro da região de um ponto flutuante do tipo <code>double-precision, </code>usando {{jsxref("Number.isSafeInteger()")}}, como também {{jsxref("Number.MAX_SAFE_INTEGER")}}, e {{jsxref("Number.MIN_SAFE_INTEGER")}}. Fora dessa região, números inteiros em JavaScript não são mais precisos e serão uma aproximação de um número de ponto flutuante do tipo <code>double-precision</code>.</p>

<p>O tipo <em>number</em> possui apenas um inteiro que tem duas representações: 0 é representado como -0 ou +0. ("0" é um pseudônimo para +0). Na prática, isso não gera grandes impactos. Por exemplo <code>+0 === -0</code>  resulta em <code>true</code>. Entretanto, você pode notar a diferença quando realiza uma divisão por 0:</p>

<pre class="brush: js notranslate">&gt; 42 / +0
Infinity
&gt; 42 / -0
-Infinity
</pre>

<p>Apesar de um número frequentemente representar somente seu valor, JavaScript fornece <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="en/JavaScript/Reference/Operators/Bitwise_Operators">alguns operadores binários</a>. Estes podem ser usados para representar muitos valores booleanos dentro de um único número usando <em><a class="external" href="http://en.wikipedia.org/wiki/Mask_%28computing%29">bit masking</a>. </em>Entretanto, isto é usualmente considerado uma má prática, desde que JavaScript oferece outros meios para representar uma configuração de booleanos (como uma array de booleanos ou um objeto com valores booleanos assinalados em propriedades). Bit masking também tende a fazer o código mais difícil de ler, entender e de realizar manutenção. Isto pode ser necessário em um ambiente bastante limitado, como quando tentamos lidar com limitação de armazenamento ou armazenamento local ou em casos extremos quando cada bit na rede conta. Esta técnica somente deveria ser considerada quando é a última medida possível para otimizar o tamanho.</p>

<h3 id="Tipo_String">Tipo "String"</h3>

<p>O tipo {{jsxref("Global_Objects/String", "String")}} em JavaScript é usado para representar dados textuais. Isto é um conjunto de "elementos" de valores de 16-bits <em>unsigned integer</em>. Cada elemento na <em>string</em> ocupa uma posição na <em>string</em>. O primeiro elemento está no índice 0, o próximo no índice 1, e assim por diante. O comprimento de uma <em>string</em> é o número de elementos nela.</p>

<p>Diferente de linguagens como C, strings em JavaScript são imutáveis. Isto significa que: uma vez criada a string, não é possível modificá-la. Entretanto, ainda é possível criar outra string baseada em um operador na string original. Por exemplo:</p>

<ul>
 <li>Uma substring da original a partir de letras individuais ou usando {{jsxref("String.substr()")}}.</li>
 <li>Uma concatenação de duas strings usando o operador (<code>+</code>) ou {{jsxref("String.concat()")}}.</li>
</ul>

<h4 id="Cuidado_com_stringly-typing_digitação_no_seu_código!">Cuidado com "stringly-typing" (digitação) no seu código!</h4>

<p>Pode ser tentador utilizar strings para representar dados complexos. Fazer isso traz os seguintes benefícios de curto prazo: </p>

<ul>
 <li>É facil construir strings complexas com concatenação.</li>
 <li>Strings são fáceis para debug (o que você vê escrito é o que está na string).</li>
 <li>Strings são o denominador comum entre várias APIs (<a href="/en-US/docs/Web/API/HTMLInputElement" title="HTMLInputElement">input fields</a>, <a href="/en-US/docs/Storage" title="Storage">local storage</a> values, {{ domxref("XMLHttpRequest") }} responses ao usar <code>responseText</code>, etc.) e pode ser tentador trabalhar apenas com strings.</li>
</ul>

<p>Com convenções, é possível representar qualquer estrutura de dados com uma string. Ainda assim, isso não faz a prática ser uma boa ideia. Por exemplo, pode-se emular uma lista utilizando separadores (um JavaScript array seria mais adequado). Infelizmente, se o separador faz parte de um dos elementos da "lista", então, a lista é quebrada. Um caracter de escape pode ser utilizado,etc. Tudo isso requer convenções e cria uma carga de manuntenção desnecessária.</p>

<p>É aconselhável usar strings para dados textuais. Quando representar dados complexos, analise as strings e utilize abstrações apropriadas.</p>

<h3 id="Symbol_type">Symbol type</h3>

<p>Symbols são novos no JavaScript ECMAScript edição 6. Um Symbol é um valor primitivo <strong>único</strong> e <strong>imutável</strong> e pode ser usado como chave de uma propriedade de Object (ver abaixo). em algumas linguagens de programação, Symbols são chamados de <em>atoms</em> (átomos). Você também pode compará-los à enumerações nomeadas (enum) em C. Para mais detalhes veja {{Glossary("Symbol")}} e o {{jsxref("Symbol")}} <em>object wrapper</em> em JavaScript.</p>

<h2 id="Objetos">Objetos</h2>

<p>Na ciência da computação, um objeto é um valor na memória que pode ser possivelmente referenciado por um {{Glossary("Identifier", "identifier")}}.</p>

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

<p>No JavaScript, obejtos podem ser vistos como uma coleção de propriedades. Com o <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Object_literals">object literal syntax</a>, um conjunto limitado de propriedades podem ser inicializados; a partir daí propriedades podem ser adicionadas e removidas. Estas propriedades podem assumir valores de qualquer tipo, incluindo outros objetos, o que permite construir estruturas de dados mais complexas. Propriedades são identificadas usando valores chave. Um valor chave pode ser uma String ou um valor Symbol.</p>

<p>Existem dois tipos de propriedades de objetos que contém certos atributos: a propriedade de dados e a propriedade de acesso.</p>

<h4 id="Propriedade_de_Dados">Propriedade de Dados</h4>

<p>Associa uma chave com um valor e tem os seguintes atributos:</p>

<table class="standard-table">
 <caption>Attributes of a data property</caption>
 <tbody>
  <tr>
   <th>Atributo</th>
   <th>Tipo</th>
   <th>Descrição</th>
   <th>Valor default</th>
  </tr>
  <tr>
   <td>[[Value]]</td>
   <td>Qualquer tipo JavaScript</td>
   <td>Valor retornado por uma chamada get da propriedade.</td>
   <td>Indefinido</td>
  </tr>
  <tr>
   <td>[[Writable]]</td>
   <td>Booleano</td>
   <td>Se <code>falso</code>, o[[Value]] da propriedade não pode ser alterado.</td>
   <td>falso</td>
  </tr>
  <tr>
   <td>[[Enumerable]]</td>
   <td>Booleano</td>
   <td>Se <code>true</code>, a propriedade será enumerda em <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a> loops.</td>
   <td>falso</td>
  </tr>
  <tr>
   <td>[[Configurable]]</td>
   <td>Booleano</td>
   <td>Se <code>falso</code>, a propriedade não pode ser deletada e atributos além de [[Value]] e [[Writable]] não podem ser alterados.</td>
   <td>falso</td>
  </tr>
 </tbody>
</table>

<h4 id="Propriedade_de_acesso">Propriedade de acesso</h4>

<p>Associa uma chave com uma ou duas funções de acesso (get e set) para retornar ou armazenar um valor e tem os seguintes atributos:</p>

<table class="standard-table">
 <caption>Atributos de uma propriedade de acesso</caption>
 <tbody>
  <tr>
   <th>Atributo</th>
   <th>Tipo</th>
   <th>Descrição</th>
   <th>Valor default</th>
  </tr>
  <tr>
   <td>[[Get]]</td>
   <td>Função objeto ou indefinido</td>
   <td>A função é chamada com uma lista de argumentos vazia e retorna o valor da propriedade sempre que é realizado um acesso get ao valor. Veja também: <a href="/en-US/docs/Web/JavaScript/Reference/Operators/get"><code>get</code></a>.</td>
   <td>Indefinido</td>
  </tr>
  <tr>
   <td>[[Set]]</td>
   <td>Função objeto ou indefinido</td>
   <td>A função é chamada com um argumento o valor designado e é executada sempre que houver uma tentativa de alteração de uma propriedade específica. Veja também: <a href="/en-US/docs/Web/JavaScript/Reference/Operators/set"><code>set</code></a>.</td>
   <td>Indefinido</td>
  </tr>
  <tr>
   <td>[[Enumerable]]</td>
   <td>Booleano</td>
   <td>Se <code>true</code>, a propriedade será enumerdada em <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a> loops.</td>
   <td>falso</td>
  </tr>
  <tr>
   <td>[[Configurable]]</td>
   <td>Boolean</td>
   <td>Se <code>falso</code>, a propriedade não pode ser deletada e não pode ser alterada para uma propriedade de dados.</td>
   <td>falso</td>
  </tr>
 </tbody>
</table>

<h3 id="Funções_e_objetos_normais">Funções e objetos "normais"</h3>

<p>Um objeto do JavaScript é um mapeamento entre chaves e valores. Chaves são Strings e valores podem ser de qualquer tipo. Isso faz com que objetos sejam perfeitos para <a class="external" href="http://en.wikipedia.org/wiki/Hash_table">hashmaps</a>.</p>

<p>Funções são objetos comuns com a capacidade adicional de serem chamados.</p>

<h3 id="Datas">Datas</h3>

<p>Quando reprensentando datas, a melhor escolha é utilizar o <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date"><code>Date</code> utility</a> já construído internamente no JavaScript.</p>

<h3 id="Coleções_indexadas_Arrays_e_Arrays_tipados">Coleções indexadas: Arrays e Arrays tipados</h3>

<p><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array" title="Array">Arrays</a> são objetos comuns nos quais existe uma relação particular entre propriedades de chaveamento inteiro e a propriedade 'length'. Além disso, arrays herdam de <code>Array.prototype</code> que nos dá vários metodos úteis para manipulação de arrays. Por exemplo, <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf" title="en/JavaScript/Reference/Global_Objects/Array/indexOf">indexOf</a></code> (procura um valor no array) ou <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/push" title="en/JavaScript/Reference/Global_Objects/Array/push">push</a></code> (adiciona um valor no array), etc. Isso faz com que os Arrays sejam candidatos perfeitos para representação de listas e conjuntos.</p>

<p><a href="/en-US/docs/Web/JavaScript/Typed_arrays">Typed Arrays</a> (arrays tipados) são novos no JavaScript com ECMAScript Edition 6 e apresenta uma visão básica similar a de um array para um data buffer binário. A tabela a seguir mostra o equivalente aos tipos de dados em C:</p>

<p>{{page("/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray", "TypedArray_objects", "", 0, 3)}}</p>

<h3 id="Coleções_chaveadas_Maps_Sets_WeakMaps_WeakSets">Coleções chaveadas: Maps, Sets, WeakMaps, WeakSets</h3>

<p>Estas estruturas de dados pegam referências de objetos como chaves e foram introduzidas no ECMAScript Edition 6. {{jsxref("Set")}} e {{jsxref("WeakSet")}} representa um conjunto de objetos, enquanto {{jsxref("Map")}} e {{jsxref("WeakMap")}} associa um valor a um objeto. A diferença entre Maps e WeakMaps é que no primeiro, as chaves dos objetos podem ser enumeradas. Isso permite otimização de garbage collection no segundo.</p>

<p>Pode-se implementar Maps e Sets no ECMAScript 5 puro. Porém, como objetos não podem ser comparados (no sentido de "menor que", por exemplo), o desempenho de pesquisa seria necessariamente linear. Implementações nativas deles (incluindo WeakMaps) podem ter uma performance de pesquisa logarítmica em relação ao tempo constante.</p>

<p>Geralmente, para vincular dados a um nó DOM, pode-se setar propriedades diretamente no objeto ou usar atributos <code>data-*</code>. Isso tem a desvantagem de os dados estarem disponíveis para qualquer script em execução no mesmo contexto. Maps e WeakMaps facilitam vincular dados privadamente a um objeto.</p>

<h3 id="Dados_estruturados_JSON">Dados estruturados: JSON</h3>

<p>JSON (JavaScript Object Notation) is a lightweight data-interchange format, derived from JavaScript but used by many programming languages. JSON builds universal data structures. See {{Glossary("JSON")}} and {{jsxref("JSON")}} for more details.</p>

<h3 id="Mais_objetos_na_biblioteca_padrão">Mais objetos na biblioteca  padrão</h3>

<p>Javascript possui uma biblioteca padrão com objetos pré-construidos.Por favor olhe a <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects">referência</a> para descobrir mais sobre objetos.</p>

<h2 id="Determinando_tipos_usando_o_operador_typeof">Determinando  tipos usando o operador <code>typeof</code></h2>

<p>O operador typeof pode lhe ajudar a encontrar o tipo de sua variavel. Por favor, leia a <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/typeof">página de referência</a> para mais detalhes e casos de uso.</p>

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

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Specification</th>
   <th scope="col">Status</th>
   <th scope="col">Comment</th>
  </tr>
  <tr>
   <td>ECMAScript 1st Edition.</td>
   <td>Standard</td>
   <td>Initial definition.</td>
  </tr>
  <tr>
   <td>{{SpecName('ES5.1', '#sec-8', 'Types')}}</td>
   <td>{{Spec2('ES5.1')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>
    <p>{{SpecName('ES6', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}</p>
   </td>
   <td>{{Spec2('ES6')}}</td>
   <td></td>
  </tr>
  <tr>
   <td>
    <table>
     <tbody>
      <tr>
       <td>{{SpecName('ESDraft', '#sec-ecmascript-data-types-and-values', 'ECMAScript Data Types and Values')}}<br>
         </td>
      </tr>
     </tbody>
    </table>
   </td>
   <td>
    <table>
     <tbody>
      <tr>
       <td>{{Spec2('ESDraft')}}</td>
      </tr>
     </tbody>
    </table>
   </td>
   <td></td>
  </tr>
 </tbody>
</table>

<h2 id="Veja_também">Veja também</h2>

<ul>
 <li><a class="link-https" href="https://github.com/nzakas/computer-science-in-javascript/">Nicholas Zakas collection of common data structure and common algorithms in JavaScript.</a></li>
 <li><a href="https://github.com/monmohan/DataStructures_In_Javascript">Search Tre(i)es implemented in JavaScript</a></li>
</ul>