initial commit

499 files changed, 72854 insertions, 0 deletions

diff --git a/files/pt-br/web/javascript/reference/about/index.html b/files/pt-br/web/javascript/reference/about/index.html
new file mode 100644
index 0000000000..849e31d917
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/about/index.html
@@ -0,0 +1,52 @@
+---
+title: Sobre esta referência
+slug: Web/JavaScript/Reference/About
+tags:
+  - JavaScript
+  - Referencia
+translation_of: Web/JavaScript/Reference/About
+---
+<div>{{JsSidebar}}</div>
+
+<div>A referência de JavaScript serve como um repositório para fatos sobre a linguagem JavaScript. A linguagem é inteiramente descrita aqui em detalhes. Quando você escreve códigos fontes em JavaScript, muitas vezes você irá precisar de referências ( por isto o titulo "Referência de JavaScript" ). Se você estiver aprendendo sobre JavaScript, ou precisa de ajuda para entender alguma das suas capacidades ou recursos, você pode conferir o <a href="/pt-BR/docs/Web/JavaScript/Guide">Guia de JavaScript</a> !</div>
+
+<div><br>
+O JavaScript é uma linguagem interpretada que se destina a ser utilizado dentro de algum ambiente maior, seja ele um script de um navegador, do lado do servidor, ou algo similar. Para a maior parte, esta referência se distinta à um ambiente agnóstico, e não somente ao ambiente de um navegador.</div>
+
+<div> </div>
+
+<h2 id="Onde_encontrar_mais_informações_sobre_JavaScript">Onde encontrar mais informações sobre JavaScript ?</h2>
+
+<p>Você pode verificar a documentação do <em>core</em> da linguagem e seus novos recursos ( <a href="/pt-BR/docs/Web/JavaScript/Language_Resources">ECMAScript</a> puro em sua maior parte), incluindo também :</p>
+
+<ul>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Guide">Guia de JavaScript</a></li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference">Referência de JavaScript</a></li>
+</ul>
+
+<p>Se você é novo com JavaScript, recomendamos à você começar com o <a href="/pt-BR/docs/Web/JavaScript/Guide">guia</a>. Uma vez que você já tenha uma base sobre os fundamentos da linguagem, você pode usar a <a href="/pt-BR/docs/Web/JavaScript/Reference">referência</a> para obter mais detalhes sobre objetos individuais e construtores da linguagem.</p>
+
+<h2 id="Estrutura_da_referência">Estrutura da referência</h2>
+
+<p>Na referência do JavaScript você poderá encontrar os seguintes seções :</p>
+
+<dl>
+ <dt><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects">Padrões de objetos internos (<em>built-in objects</em>)</a></dt>
+ <dd>Esta seção documenta todos o padrão JavaScript de objetos internos, juntamente com seus métodos e propriedades.</dd>
+ <dt><a href="/pt-BR/docs/Web/JavaScript/Reference/Statements">Instruções e Declarações (<em>Statements</em>)</a></dt>
+ <dd>As aplicações em JavaScript consistem em declarações com uma sintaxe apropriada. Uma única declaração pode abranger várias linhas de código. Várias instruções podem ocorrer em uma única linha também, se cada declaração for devidamente separada por ponto e virgula. Instrução não é uma palavra-chave, mas sim, um grupo de palavras-chave.</dd>
+ <dt><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators">Expressões e operadores</a></dt>
+ <dd>Esta seção documenta todos os operadores da linguagem JavaScript, expressões e palavras-chave.</dd>
+ <dt><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions">Funções</a></dt>
+ <dd>Esta seção é referente as funções existentes no JavaScript.</dd>
+ <dt><a href="/pt-BR/docs/Web/JavaScript/New_in_JavaScript">Novo no JavaScript</a></dt>
+ <dd>Esta seção é sobre as versões do JavaScript, contendo o histórico de versões e o que há de novo nas proximas versões.</dd>
+</dl>
+
+<h3 id="Mais_paginas_de_referências">Mais paginas de referências</h3>
+
+<ul>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features">Recursos e funcionalidades obsoletas</a></li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar">Gramática Léxica</a></li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Data_structures">Tipos e estruturas de dados</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/classes/constructor/index.html b/files/pt-br/web/javascript/reference/classes/constructor/index.html
new file mode 100644
index 0000000000..3b8a64429b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/classes/constructor/index.html
@@ -0,0 +1,174 @@
+---
+title: constructor
+slug: Web/JavaScript/Reference/Classes/constructor
+tags:
+  - Classes
+  - ECMAScript6
+  - Experimental
+  - JavaScript orientado a objetos
+  - Nova versão JavaScript
+translation_of: Web/JavaScript/Reference/Classes/constructor
+---
+<div>O construtor é um método especial para criar e inicializar um objeto criado a partir de uma classe.</div>
+
+<div></div>
+
+<div></div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">constructor([argumentos]) { ... }</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Apenas um método especial com o nome <em>constructor</em> pode existir em uma classe. O erro {{jsxref("SyntaxError")}} será mostrado se a classe contiver mais de um método <em>constructor.</em></p>
+
+<p>Um construtor pode usar a palavra reservada <em>super</em> para se referir ao construtor da classe pai (<strong>superior</strong>).</p>
+
+<p>Um construtor padrão será usado se você não especificá-lo<em>.</em></p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_constructor">Usando o método <em>constructor</em></h3>
+
+<p>O trecho de código foi fornecido por <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">exemplo de classes</a> (<a href="https://googlechrome.github.io/samples/classes-es6/index.html">live demo</a>).</p>
+
+<pre class="brush: js notranslate">class Quadrado extends Poligono {
+  constructor(comprimento) {
+    // super chama o construtor da classe pai que vai atribuir comprimento para
+    // os atributos comprimento e altura herdados pela nossa classe filha Quadrado
+    super(comprimento, comprimento);
+    // Nas classes filhas, <em>super()</em> deve ser chamado antes de usar o <em>this</em>. Sem ele
+    // vai ocorrer um erro de referência. O <em>this</em> agora se refere a classe filha Quadrado
+    this.nome = 'Quadrado';
+  }
+
+  // os atributos a seguir são herdados da classe pai Poligono: altura, comprimento e area.
+
+  get area() {
+    return this.altura * this.comprimento;
+  }
+
+  set area(valor) {
+    this.area = valor;
+  }
+}</pre>
+
+<h3 id="Construtores_padrão_constructors">Construtores padrão (<em>constructors</em>)</h3>
+
+<p>Um construtor padrão será usado pela classe caso nenhum seja especificado. Para as classes de base o construtor padrão é:</p>
+
+<pre class="brush: js notranslate">constructor() {} //construtor criado por padrão
+</pre>
+
+<p>Para as classes filhas o construtor padrão é:</p>
+
+<pre class="brush: js notranslate">constructor(...args) {
+  super(...args);
+}</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-static-semantics-constructormethod', 'Constructor Method')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-static-semantics-constructormethod', 'Constructor Method')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p><br>
+ Download da versão Firefox para testes (Nightly) em: https://nightly.mozilla.org/</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>Chrome(42.0)</td>
+   <td>Nightly</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido</td>
+  </tr>
+  <tr>
+   <td>Construtores padrão</td>
+   <td>Desconhecido</td>
+   <td>Nightly</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>Não</td>
+   <td>Chrome(42.0)</td>
+   <td>CompatNightly</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido</td>
+   <td>CompatChrome(42.0)</td>
+  </tr>
+  <tr>
+   <td>Construtores padrão</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido</td>
+   <td>CompatNightly</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido</td>
+   <td>Desconhecido}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="sect1"></h2>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/super">super()</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> expressão</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class"><code>class</code> declaração</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/classes/extends/index.html b/files/pt-br/web/javascript/reference/classes/extends/index.html
new file mode 100644
index 0000000000..534a1c2e33
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/classes/extends/index.html
@@ -0,0 +1,106 @@
+---
+title: extends
+slug: Web/JavaScript/Reference/Classes/extends
+tags:
+  - Classes
+  - ECMAScript6
+  - Experimental
+  - Herança
+  - JavaScript
+  - extends
+translation_of: Web/JavaScript/Reference/Classes/extends
+---
+<div>{{jsSidebar("Classes")}}</div>
+
+<p>A palavra chave <strong><code>extends</code></strong> é usada em uma <a href="/en-US/docs/Web/JavaScript/Reference/Statements/class">class declarations</a> ou <a href="/en-US/docs/Web/JavaScript/Reference/Operators/class">class expressions</a> para criar uma classe filha de outra classe.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">class ChildClass extends ParentClass { ... }</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A palavra chave extends pode ser usada para tanto classes filhas quanto objetos filhos pré-construidos.</p>
+
+<p>O <code>.prototype</code> da extensão deve ser um {{jsxref("Object")}} ou {{jsxref("null")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_extends">Usando <code>extends</code></h3>
+
+<p>O primeiro exemplo cria uma classe chamada <code>Square</code> a partir de uma classe chamada <code>Polygon</code>. Este exemplo foi extraido deste <a href="https://googlechrome.github.io/samples/classes-es6/index.html">live demo</a> <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">(source)</a>.</p>
+
+<pre class="brush: js">class Square extends Polygon {
+  constructor(length) {
+    // Here, it calls the parent class' constructor with lengths
+    // provided for the Polygon's width and height
+    super(length, length);
+    // Note: In derived classes, super() must be called before you
+    // can use 'this'. Leaving this out will cause a reference error.
+    this.name = 'Square';
+  }
+
+  get area() {
+    return this.height * this.width;
+  }
+
+  set area(value) {
+    this.area = value;
+  }
+}</pre>
+
+<h3 id="Usando_extends_com_objetos_pré-construidos">Usando <code>extends</code> com objetos pré-construidos</h3>
+
+<p>Este exemplo extende o objeto pré-construido {{jsxref("Date")}}. Este exemplo foi extraido deste <a href="https://googlechrome.github.io/samples/classes-es6/index.html">live demo</a> <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">(source)</a>.</p>
+
+<pre class="brush: js">class myDate extends Date {
+  constructor() {
+    super();
+  }
+
+  getFormattedDate() {
+    var months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec'];
+    return this.getDate() + "-" + months[this.getMonth()] + "-" + this.getFullYear();
+  }
+}</pre>
+
+<h3 id="Estendendo_null">Estendendo <code>null</code></h3>
+
+<p>Estender de {{jsxref("null")}} funciona como em uma classe normal, exceto que o objeto prototype não herda de {{jsxref("Object.prototype")}}.</p>
+
+<pre class="brush: js"><code>class nullExtends extends null {
+  constructor() {}
+}
+
+Object.getPrototypeOf(nullExtends); // Function.prototype
+Object.getPrototypeOf(nullExtends.prototype) // null</code></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-class-definitions', 'extends')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+
+
+<p>{{Compat("javascript.classes.extends")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/super">super</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/classes/index.html b/files/pt-br/web/javascript/reference/classes/index.html
new file mode 100644
index 0000000000..62f5d0270f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/classes/index.html
@@ -0,0 +1,364 @@
+---
+title: Classes
+slug: Web/JavaScript/Reference/Classes
+tags:
+  - Classes
+  - Constructor
+  - ECMAScript6
+  - Herança
+  - Intermediário
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Classes
+---
+<div>{{JsSidebar("Classes")}}</div>
+
+<p>Classes em JavaScript são introduzidas no ECMAScript 2015 e são simplificações da linguagem para as heranças baseadas nos protótipos. A sintaxe para classes <strong>não</strong> introduz um novo modelo de herança de orientação a objetos em JavaScript. Classes em JavaScript provêm uma maneira mais simples e clara de criar objetos e lidar com herança.</p>
+
+<h2 id="Definindo_classes">Definindo classes</h2>
+
+<p>As Classes são, de fato, "funções especiais", e, assim como você pode definir <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/function">"function expressions"</a> e <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/function">"function declarations"</a>, a sintaxe de uma classe possui dois componentes: <a href="/en-US/docs/Web/JavaScript/Reference/Operators/class">"class expressions</a>" e  <a href="/en-US/docs/Web/JavaScript/Reference/Statements/class">"class declarations"</a>.</p>
+
+<h3 id="Declarando_classes">Declarando classes</h3>
+
+<p>Uma maneira de definir uma classe é usando uma declaração de classe. Para declarar uma classe, você deve usar a palavra-chave <code>class</code> seguida pelo nome da classe (aqui "Retangulo").</p>
+
+<pre class="brush: js">class Retangulo {
+  constructor(altura, largura) {
+    this.altura = altura;
+    this.largura = largura;
+  }
+}</pre>
+
+<h4 id="Uso_antes_da_declaração_Hoisting_-_Tradução_Literal_Lançamento">Uso antes da declaração (Hoisting - Tradução Literal: Lançamento)</h4>
+
+<p>Uma diferença importante entre <strong>declarações de funções</strong> das <strong>declarações de classes</strong>, é que  declararações de  funções são {{Glossary("Hoisting", "hoisted")}} e declarações de classes não são. Primeiramente deve declarar sua classe para só então acessá-la, pois do contrário o código a seguir irá lançar uma exceção: {{jsxref("ReferenceError")}}:</p>
+
+<pre class="brush: js example-bad">const p = new Retangulo(); // Erro de referência (ReferenceError)
+
+class Retangulo {}
+</pre>
+
+<h3 id="Expressões_de_Classes">Expressões de Classes</h3>
+
+<p>Uma <strong>Expressão de Classe</strong> (class expression) é outra forma para definir classes. Expressões de Classes podem possuir nomes ou não (anônimas). O nome dado para uma expressão de classe é local ao corpo da classe.</p>
+
+<pre class="brush: js">// sem nome
+let Retangulo = class {
+  constructor(altura, largura) {
+    this.altura = altura;
+    this.largura = largura;
+  }
+};
+
+// nomeada
+let Retangulo = class Retangulo {
+  constructor(altura, largura) {
+    this.altura = altura;
+    this.largura = largura;
+  }
+};
+</pre>
+
+<p><strong>Nota:</strong> As <strong>expressões de classe</strong> também sofrem com o mesmo problema de {{Glossary("Hoisting", "hoisted")}} mencionados em <strong>declarações </strong>de classe.</p>
+
+<h2 id="Corpo_de_uma_classe_e_definições_de_métodos">Corpo de uma classe e definições de métodos</h2>
+
+<p>O corpo de uma classe é a parte que está entre chaves <code>{}</code>. É aí onde você define os membros da classe, como os métodos, ou os construtores.</p>
+
+<h3 id="Modo_Estrito_strict_mode">Modo Estrito (strict mode)</h3>
+
+<p>Os corpos das Declarações de Classes e das Expressões de Classes são executados em <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Strict_mode">modo estrito</a>.</p>
+
+<h3 id="Construtor">Construtor</h3>
+
+<p>O método <code><a href="/en-US/docs/Web/JavaScript/Reference/Classes/constructor">constructor</a></code> é um tipo especial de método para criar e iniciar um objeto criado pela classe. Só pode existir um método especial com o nome "constructor" dentro da classe. Um erro de sintáxe {{jsxref("SyntaxError")}} será lançado se a classe possui mais do que uma ocorrência do método <code>constructor</code>.</p>
+
+<p>Um construtor pode usar a palavra-chave <code>super</code> para chamar o construtor de uma classe pai.</p>
+
+<h3 id="Métodos_Protótipos">Métodos Protótipos</h3>
+
+<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions">definições de métodos (method definitions)</a>.</p>
+
+<pre class="brush: js">class Retangulo {
+    constructor(altura, largura) {
+      this.altura = altura; this.largura = largura;
+    }
+  //Getter
+    get area() {
+        return this.calculaArea()
+    }
+
+    calculaArea() {
+        return this.altura * this.largura;
+    }
+}
+
+const quadrado = new Retangulo(10, 10);
+
+console.log(quadrado.area);</pre>
+
+<h3 id="Métodos_estáticos">Métodos estáticos</h3>
+
+<p>A palavra-chave <code><a href="/en-US/docs/Web/JavaScript/Reference/Classes/static">static</a></code> define um método estático de uma classe. Métodos estáticos são chamados sem a instanciação da sua classe e não podem ser chamados quando a classe é instanciada. Métodos estáticos são geralmente usados para criar funções de utilidades por uma aplicação.</p>
+
+<pre class="brush: js">class Ponto {
+    constructor(x, y) {
+        this.x = x;
+        this.y = y;
+    }
+
+    static distancia(a, b) {
+        const dx = a.x - b.x;
+        const dy = a.y - b.y;
+
+        return Math.hypot(dx, dy);
+    }
+}
+
+const p1 = new Ponto(5, 5);
+const p2 = new Ponto(10, 10);
+
+p1.distancia; //undefined
+p2.distancia; //undefined
+
+console.log(Ponto.distancia(p1, p2));</pre>
+
+<h3 id="Empacotando_com_protótipos_e_métodos_estáticos">Empacotando com protótipos e métodos estáticos</h3>
+
+<p>Quando um método estático ou protótipo é chamado sem um objeto "this" configurado (ou com "this" como boolean, string, number, undefined ou null), então o valor "this" será <strong><code>undefined</code></strong> dentro da função chamada. Autoboxing não vai acontecer. O comportamento será o mesmo mesmo se escrevemos o código no modo não-estrito.</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">class</span> <span class="class-name token">Animal</span> <span class="punctuation token">{</span>
+  falar<span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">;</span>
+  <span class="punctuation token">}</span>
+  <span class="keyword token">static</span> comer<span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">;</span>
+  <span class="punctuation token">}</span>
+<span class="punctuation token">}</span>
+
+<span class="keyword token">let</span> obj <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Animal</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;
+obj.falar(); // Animal {}</span>
+<span class="keyword token">let</span> falar <span class="operator token">=</span> obj<span class="punctuation token">.</span>falar<span class="punctuation token">;</span>
+falar<span class="punctuation token">()</span><span class="punctuation token">;</span> <span class="comment token">// undefined</span>
+
+Animal.comer(); // class Animal
+<span class="keyword token">let</span> comer <span class="operator token">=</span> Animal<span class="punctuation token">.</span>comer<span class="punctuation token">;</span>
+<span class="function token">comer</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// undefined</span></code></pre>
+
+<p>Se escrevemos o código acima usando classes baseadas em função tradicional, então o autoboxing acontecerá com base no valor de "this" para o qual a função foi chamada.</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">Animal</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span> <span class="punctuation token">}</span>
+
+Animal<span class="punctuation token">.</span>prototype<span class="punctuation token">.</span>falar <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">;</span>
+<span class="punctuation token">}</span>
+
+Animal<span class="punctuation token">.</span>comer <span class="operator token">=</span> <span class="keyword token">function</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  <span class="keyword token">return</span> <span class="keyword token">this</span><span class="punctuation token">;</span>
+<span class="punctuation token">}</span>
+
+<span class="keyword token">let</span> obj <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Animal</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="keyword token">let</span> falar <span class="operator token">=</span> obj<span class="punctuation token">.</span>falar<span class="punctuation token">;</span>
+falar<span class="punctuation token">()</span><span class="punctuation token">;</span> <span class="comment token">// objeto global</span>
+
+<span class="keyword token">let</span> comer <span class="operator token">=</span> Animal<span class="punctuation token">.</span>comer<span class="punctuation token">;</span>
+comer<span class="punctuation token">()</span><span class="punctuation token">;</span> <span class="comment token">// objeto global</span></code></pre>
+
+<h3 id="Propriedades_de_instância">Propriedades de instância</h3>
+
+<p>Propriedades de instâncias devem ser definidas dentro dos métodos da classe:</p>
+
+<pre><code>class Retangulo {
+  constructor(altura, largura) {
+    this.altura = altura;
+    this.largura = largura;
+  }
+}</code>
+</pre>
+
+<p>Propriedades de dados estáticos e propriedades de dados prototipados (prototype) devem ser definidos fora da declaração do corpo da classe.</p>
+
+<pre><code>Retangulo.larguraEstatico = 20;
+Retangulo.prototype.larguraPrototipagem = 25;</code></pre>
+
+<h2 id="Sub_classes_com_o_extends">Sub classes com o <code>extends</code></h2>
+
+<p>A palavra-chave <code><a href="/en-US/docs/Web/JavaScript/Reference/Classes/extends">extends</a></code> é usada em uma <em>declaração de classe</em>, ou em uma <em>expressão de classe </em>para criar uma classe como filha de uma outra classe.</p>
+
+<pre class="brush: js">class Animal {
+  constructor(nome) {
+    this.nome = nome;
+  }
+
+  falar() {
+    console.log(this.nome + ' emite um barulho.');
+  }
+}
+
+class Cachorro extends Animal {
+  falar() {
+    console.log(this.nome + ' latidos.');
+  }
+}
+
+<code class="language-js"><span class="keyword token">let</span> cachorro <span class="operator token">=</span> <span class="keyword token">new</span> </code>Cachorro<code class="language-js"><span class="punctuation token">(</span><span class="string token">'Mat'</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+cachorro<span class="punctuation token">.</span></code>falar<code class="language-js"><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span></code>
+</pre>
+
+<p>Se existir um contrutor nas subclasses, é necessário primeiro chamar super() antes de usar a keyword "this".</p>
+
+<p>Também é possivel ampliar (extends) "classes" baseadas em funções tradicionais.</p>
+
+<pre class="brush: js">function Animal (nome) {
+  this.nome = nome;
+}
+
+Animal.prototype.falar = function() {
+   console.log(this.nome + ' faça barulho.');
+}
+
+class Cachorro extends Animal {
+  falar() {
+    console.log(this.nome + ' lati.');
+  }
+}
+
+let cachorro = new Cachorro('Mitzie');
+cachorro.falar(); // Mitzie lati.</pre>
+
+<p>Note que classes não extendem objetos normais (não construíveis). Se você quer herdar de um objeto, é necessário utilizar {{jsxref("Object.setPrototypeOf()")}}:</p>
+
+<pre class="brush: js"><code>let Animal = {
+   falar() {
+      console.log(this.nome + ' faça barulho.');
+   }
+};
+
+class Cachorro {
+   constructor(nome) {
+      this.nome = nome;
+</code>   }
+}
+
+Object.setPrototypeOf(Cachorro.prototype, Animal);
+
+let cachorro = new Cachorro('Mitzie');
+cachorro.falar(); //Mitzie faça barulho.</pre>
+
+<h2 id="Species">Species</h2>
+
+<p>Você pode querer retornar um objeto {{jsxref("Array")}} na sua classe <code>MinhaArray</code> derivada de array. O padrão Species permite a sobrescrita do construtor padrão.</p>
+
+<p>Por exemplo, quando utilizando um método como {{jsxref("Array.map", "map()")}} que retorna o construtor padrão, você pode querer que esse método retorne um objeto <code>Array</code> ao invés do objeto <code>MinhaArray</code>. O {{jsxref("Symbol.species")}} te permite fazer isso:</p>
+
+<pre class="brush: js">class MinhaArray extends Array {
+   // Sobrescreve species para o construtor da classe pai Array
+   static get [Symbol.species]() { return Array; }
+}
+
+let a = new MinhaArray(1,2,3);
+let mapped = a.map(x =&gt; x * x);
+
+console.log(mapped instanceof MyArray); // false
+console.log(mapped instanceof Array); // true
+</pre>
+
+<h2 id="Chamada_da_classe_pai_com_super">Chamada da classe pai com <code>super</code></h2>
+
+<p>A palavra-chave (keyword) <code>super</code> é utilizada para chamar funções que pertencem ao pai do objeto.</p>
+
+<pre class="brush: js">class Gato {
+   constructor(nome) {
+      this.nome = nome;
+   }
+
+   falar() {
+      console.log(this.nome + ' faça barulho.');
+   }
+}
+
+class Leao extends Gato {
+   falar() {
+      super.falar();
+      console.log(this.nome + ' roars.');
+   }
+}
+
+let leao = new Leao('Fuzzy');
+leao.falar();
+
+// Fuzzy faça barulho.
+// Fuzzy roars.
+
+</pre>
+
+<h2 id="Mix-ins">Mix-ins</h2>
+
+<p>Subclasses abstratas ou <em>mix-ins</em> são templates para classes. Uma classe do ECMAScript pode apenas ter uma classe pai, assim sendo, não é possível a classe ter herança múltipla.</p>
+
+<p>Para se ter um comportamento similar ao de herança múltipla no ECMAScript usa-se mix-ins, uma forma de implementar mix-ins é usar um template de subclasse que é uma função que instancia uma classe base e retorna uma subclasse extendida desta classe base:</p>
+
+<pre class="brush: js">class Humano {
+  constructor(nome) {
+    this.nome = nome;
+  }
+  andar() {
+    return this.nome+' andou um passo'
+  }
+}
+
+const HumanoFalante = Base =&gt; class extends Base {
+  falar() {
+    return this.nome+' diz: olá mundo!'
+  }
+}
+
+const HumanoFalanteMixado = Base =&gt; class extends Base {}
+
+const HumanoFinal = HumanoFalanteMixado(HumanoFalante(Humano))
+
+const humano = new HumanoFinal('Bill Gates')
+
+console.log(humano.andar())
+console.log(humano.falar())
+</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-class-definitions', 'Class definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.classes")}}</p>
+
+<h2 id="Rodando_com_Scratchpad">Rodando com Scratchpad</h2>
+
+<p>Uma classe não pode ser redefinida. Se você estiver rodando código com Scratchpad (Menu do Firefox Ferramentas &gt; Web Developer &gt; Scratchpad) e você acionar 'Run' a uma definição de uma classe com o mesmo nome duas vezes, você verá um confuso SyntaxError: redeclaration of let &lt;class-name&gt; (Erro de Sintaxe: redeclaração de let &lt;nome-da-classe&gt;).</p>
+
+<p>Para reacionar (re-run) uma definição, use o menu do Scratchpad em Execute &gt; Reload and Run (Executar &gt; Atualizar e Rodar).<br>
+ Por favor, vote no bug <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1428672">#1428672</a>.</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions">Funções</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class">Declaração de <code>classes</code> (class declaration</a>)</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class">Expressão de <code>classes</code> (class expression</a>)</li>
+ <li>{{jsxref("Operators/super", "super")}}</li>
+ <li><a href="https://hacks.mozilla.org/2015/07/es6-in-depth-classes/">Blog post: "ES6 In Depth: Classes"</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/classes/static/index.html b/files/pt-br/web/javascript/reference/classes/static/index.html
new file mode 100644
index 0000000000..4bf01b5899
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/classes/static/index.html
@@ -0,0 +1,131 @@
+---
+title: static
+slug: Web/JavaScript/Reference/Classes/static
+tags:
+  - Classes
+  - ECMAScript 2015
+  - Experimental
+  - JavaScript
+  - Static
+translation_of: Web/JavaScript/Reference/Classes/static
+---
+<div>{{jsSidebar("Classes")}}</div>
+
+<p>A palavra chave <strong>static</strong> define um método estático para a classe. Métodos estáticos não são chamados na instâncias da classe. Em vez disso, eles são chamados na própria classe. Geralmente, são funções utilitárias, como funções para criar ou clonar objetos.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">static nomeDoMetodo() { ... }</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Chamadas a métodos estáticos são feitas diretamente na classe e não podem ser feitas em uma instância da classe. Métodos estáticos são comumente utilizados como funções utilitárias.</p>
+
+<h2 id="Chamada_de_métodos_estáticos">Chamada de métodos estáticos</h2>
+
+<h3 id="De_outro_método_estático">De outro método estático</h3>
+
+<p>Para chamar um método estático dentro de outro método estático da mesma classe, podemos utilizar a palavra reservada <code>this</code>.</p>
+
+
+
+<pre class="brush: js"><code>class ChamadaDoMetodoEstatico {
+  static metodoEstatico() {
+    return 'O método estático foi chamado';
+  }
+  static outroMetodoEstatico() {
+    return this.metodoEstatico() + ' de outro método estático';
+  }
+}
+ChamadaDoMetodoEstatico.metodoEstatico();
+// 'O método estático foi chamado'
+
+ChamadaDoMetodoEstatico.outroMetodoEstatico();
+// 'O método estático foi chamado de outro método estático'</code>
+</pre>
+
+<h3 id="De_outro_construtor_e_outros_métodos">De outro construtor e outros métodos</h3>
+
+<p>Métodos estáticos não são diretamente acessíveis utilizando-se <code>this </code>a partir de métodos não estáticos. É necessário chamá-los usando o nome da classe:</p>
+
+<pre class="brush: js">nomeDaClasse.nomeDoMetodoEstatico()</pre>
+
+<p>ou chamando o método como uma propriedade do construtor:</p>
+
+<pre class="brush: js">this.constructor.nomeDoMetodoEstatico().</pre>
+
+
+
+
+
+<pre class="brush: js"><code>class ChamadaDoMetodoEstatico {
+  constructor() {
+    console.log(ChamadaDoMetodoEstatico.MetodoEstatico());
+    // 'O método estático foi chamado.'
+
+    console.log(this.constructor.MetodoEstatico());
+    // 'O método estático foi chamado.'
+  }
+
+  static MetodoEstatico() {
+    return 'O método estático foi chamado.';
+  }
+}</code></pre>
+
+
+
+
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>O exemplo a seguir demonstra várias coisas. Ele mostra como um método estático é implementado em uma classe e como uma classe com um membro estático pode virar uma subclasse. Por fim, ele mostra como um método estático pode e não pode ser chamado.</p>
+
+<pre class="brush: js">class Tripple {
+  static tripple(n) {
+    n = n | 1;
+    return n * 3;
+  }
+}
+
+class BiggerTripple extends Tripple {
+  static tripple(n) {
+    return super.tripple(n) * super.tripple(n);
+  }
+}
+
+console.log(Tripple.tripple());
+console.log(Tripple.tripple(6));
+console.log(BiggerTripple.tripple(3));
+var tp = new Tripple();
+console.log(tp.tripple()); //Logs 'tp.tripple is not a function'.</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('ES2015', '#sec-class-definitions', 'Class definitions')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+
+
+<p>{{Compat("javascript.classes.static")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> expression</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class"><code>class</code> declaration</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/deprecated_and_obsolete_features/index.html b/files/pt-br/web/javascript/reference/deprecated_and_obsolete_features/index.html
new file mode 100644
index 0000000000..3551afdb67
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/deprecated_and_obsolete_features/index.html
@@ -0,0 +1,294 @@
+---
+title: Deprecated and obsolete features
+slug: Web/JavaScript/Reference/Deprecated_and_obsolete_features
+tags:
+  - Depreciado
+  - Obsoleto
+translation_of: Web/JavaScript/Reference/Deprecated_and_obsolete_features
+---
+<div>{{JsSidebar("More")}}</div>
+
+<p>Esta página lista funcionalidades do JavaScript que foram descontinuadas (ou seja, continuam disponíveis mas têm remoção planejada) e obsoletas (ou seja, não estão mais disponíveis).</p>
+
+<h2 id="Funcionalidades_descontinuadas"><em>Funcionalidades   </em>descontinuadas</h2>
+
+<p>Estas <em>features</em> descontinuadas ainda podem ser usadas, mas com cautela, porque espera-se que sejam removidas por completo no futuro. Aconselha-se que remova-as do seu código.</p>
+
+<h3 id="Propriedades_RegExp">Propriedades RegExp</h3>
+
+<p>As propriedades a seguir foram descontinuadas. Isto não afeta o uso delas em {{jsxref("String.replace", "replacement strings", "", 1)}}:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Propriedade</th>
+   <th>Descrição</th>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.n", "$1-$9")}}</td>
+   <td>
+    <p>Encontra <em>substrings </em>dentro de parênteses.<br>
+     <strong>Atenção: </strong> Usar estas propriedades pode resultar em problemas, porque extensões do navegador podem modifica-las. Evite-as!</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.input", "$_")}}</td>
+   <td>Ver <code>input</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.multiline", "$*")}}</td>
+   <td>Ver <code>multiline</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastMatch", "$&amp;")}}</td>
+   <td>Ver <code>lastMatch</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastParen", "$+")}}</td>
+   <td>Ver <code>lastParen</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.leftContext", "$`")}}</td>
+   <td>Ver <code>leftContext</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.rightContext", "$'")}}</td>
+   <td>Ver <code>rightContext</code>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.input", "input")}}</td>
+   <td>A string encontrada por uma expressão regular.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastMatch", "lastMatch")}}</td>
+   <td>Os últimos caracteres encontrados.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastParen", "lastParen")}}</td>
+   <td>A última <em>substring</em> entre parênteses que foi encontrada.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.leftContext", "leftContext")}}</td>
+   <td>A penúltima <em>substring</em> encontrada.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.rightContext", "rightContext")}}</td>
+   <td>A <em>substring</em> que segue a que foi encontrada por último.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>As propriedades a seguir pertencem a instâncias de um <code>RegExp</code>, não mais ao objeto <code>RegExp</code>:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Propriedades</th>
+   <th>Descrição</th>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.global", "global")}}</td>
+   <td>Determina se deve ou não testar a expressão regular com todas as combinações possíveis em uma <em>string</em> ou só com a primeira.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.ignoreCase", "ignoreCase")}}</td>
+   <td>Determina se deve ou não ignorar a capitalização ao tentar encontrar uma combinação em uma <em>string</em>.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.lastIndex", "lastIndex")}}</td>
+   <td>O índince que aponta o começo da próxima combinação.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.multiline", "multiline")}}</td>
+   <td>Determina se deve ou não procurar por <em>strings</em> em várias linhas diferentes.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("RegExp.source", "source")}}</td>
+   <td>O texto do padrão.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="Métodos_RegExp">Métodos RegExp</h3>
+
+<ul>
+ <li>O método  {{jsxref("RegExp.compile", "compile()")}} foi descontinuado.</li>
+ <li>O método <code>valueOf</code>  não é mais especializado para <code>RegExp</code>. Use {{jsxref("Object.valueOf()")}}.</li>
+</ul>
+
+<h3 id="Propriedades_de_Função">Propriedades de Função</h3>
+
+<ul>
+ <li>As propriedades {{jsxref("Global_Objects/Function/caller", "caller")}} e {{jsxref("Global_Objects/Function/arguments", "arguments")}} foram descontinuadas, porque elas estouram o chamador de funções. Ao invés da propriedade <em>arguments</em>, deve-se usar o objeto {{jsxref("Functions/arguments", "arguments")}} dentro dos fechamentos da função.</li>
+</ul>
+
+<h3 id="Legacy_generator">Legacy generator</h3>
+
+<ul>
+ <li>{{jsxref("Statements/Legacy_generator_function", "Legacy generator function statement")}} e {{jsxref("Operators/Legacy_generator_function", "Legacy generator function expression")}} foram descontinuados. No lugar deles, use {{jsxref("Statements/function*", "function* statement")}} e {{jsxref("Operators/function*", "function* expression")}}.</li>
+ <li>O {{jsxref("Operators/Array_comprehensions", "JS1.7/JS1.8 Array comprehension", "#Differences_to_the_older_JS1.7.2FJS1.8_comprehensions")}} e o {{jsxref("Operators/Generator_comprehensions", "JS1.7/JS1.8 Generator comprehension", "#Differences_to_the_older_JS1.7.2FJS1.8_comprehensions")}} foram descontinuados.</li>
+</ul>
+
+<h3 id="Iterador">Iterador</h3>
+
+<ul>
+ <li>{{jsxref("Global_Objects/StopIteration", "StopIteration")}} foi descontinuado.</li>
+ <li>{{jsxref("Global_Objects/Iterator", "Iterator")}} foi descontinuado.</li>
+</ul>
+
+<h3 id="Métodos_de_objeto">Métodos de objeto</h3>
+
+<ul>
+ <li>{{jsxref("Object.watch", "watch")}} e {{jsxref("Object.unwatch", "unwatch")}} foram descontinuados. No lugar deles, use {{jsxref("Proxy")}} .</li>
+ <li><code>__iterator__</code> foi descontinuado.</li>
+ <li>{{jsxref("Object.noSuchMethod", "__noSuchMethod__")}} foi descontinuado. Use {{jsxref("Proxy")}} em seu lugar.</li>
+</ul>
+
+<h3 id="Métodos_de_data">Métodos de data</h3>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Date/getYear", "getYear")}} e {{jsxref("Global_Objects/Date/setYear", "setYear")}} foram afetados pelo Bug do Milênio e foram reagrupados em {{jsxref("Global_Objects/Date/getFullYear", "getFullYear")}} e {{jsxref("Global_Objects/Date/setFullYear", "setFullYear")}}.</li>
+ <li>Deve-se usar {{jsxref("Global_Objects/Date/toISOString", "toISOString")}} ao invés do método descontinuado {{jsxref("Global_Objects/Date/toGMTString", "toGMTString")}} em códigos novos.</li>
+ <li>{{jsxref("Global_Objects/Date/toLocaleFormat", "toLocaleFormat")}} foi descontinuado.</li>
+</ul>
+
+<h3 id="Funções">Funções</h3>
+
+<ul>
+ <li>{{jsxref("Operators/Expression_closures", "Expression closures", "", 1)}} foram descontinuadas. Use {{jsxref("Operators/function", "functions")}} normais ou {{jsxref("Functions/Arrow_functions", "arrow functions", "", 1)}} no lugar delas.</li>
+</ul>
+
+<h3 id="Proxy">Proxy</h3>
+
+<ul>
+ <li><a href="/en-US/docs/Archive/Web/Old_Proxy_API">Proxy.create</a> e <a href="/en-US/docs/Archive/Web/Old_Proxy_API">Proxy.createFunction</a> foram descontinuadas. Use {{jsxref("Proxy")}} no lugar delas.</li>
+ <li>As armadilhas a seguir ficaram obsoletas:
+  <ul>
+   <li><code>hasOwn</code> ({{bug(980565)}}, Firefox 33).</li>
+   <li><code>getEnumerablePropertyKeys</code> ({{bug(783829)}}, Firefox 37)</li>
+   <li><code>getOwnPropertyNames</code> ({{bug(1007334)}}, Firefox 33)</li>
+   <li><code>keys</code> ({{bug(1007334)}}, Firefox 33)</li>
+  </ul>
+ </li>
+</ul>
+
+<h3 id="let">let</h3>
+
+<ul>
+ <li>{{jsxref("Statements/let", "let blocks", "#let_block")}} e {{jsxref("Statements/let", "let expressions", "#let_expressions")}} foram descontinuados.</li>
+</ul>
+
+<h3 id="Sequências_de_escape">Sequências de escape</h3>
+
+<ul>
+ <li>Sequências de escape octais (\ seguido por um, dois ou três dígitos octais) foram descontinuadas em literais <em>string</em> e expressões regulares.</li>
+ <li>As funções {{jsxref("Global_Objects/escape", "escape")}} e {{jsxref("Global_Objects/unescape", "unescape")}} foram descontinuadas. Use {{jsxref("Global_Objects/encodeURI", "encodeURI")}}, {{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent")}}, {{jsxref("Global_Objects/decodeURI", "decodeURI")}} ou {{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent")}} para codificar e decodificar sequências de escape para caracteres especiais.</li>
+</ul>
+
+<h3 id="Métodos_de_string">Métodos de <em>string</em></h3>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/en-US/docs/tag/HTML%20wrapper%20methods">HTML wrapper methods</a> como {{jsxref("String.prototype.fontsize")}} e {{jsxref("String.prototype.big")}}.</li>
+ <li>{{jsxref("String.prototype.quote")}} foi removido do Firefox 37.</li>
+ <li>parâmetros flag não padrões em {{jsxref("String.prototype.search")}}, {{jsxref("String.prototype.match")}}, e {{jsxref("String.prototype.replace")}} foram depreciados.</li>
+</ul>
+
+<h2 id="Features_obsoletas"><em>Features</em> obsoletas</h2>
+
+<p>Estas <em>features</em> obsoletas foram totamente removidas do JavaScript e não podem ser usadas a partir da versão indicada do JavaScript.</p>
+
+<h3 id="Object">Object</h3>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Property</th>
+   <th>Description</th>
+  </tr>
+  <tr>
+   <td>{{jsxref("Global_Objects/Object/count", "__count__")}}</td>
+   <td>Returns the number of enumerable properties directly on a user-defined object.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Global_Objects/Object/Parent", "__parent__")}}</td>
+   <td>Points to an object's context.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Global_Objects/Object/eval", "Object.prototype.eval()")}}</td>
+   <td>Evaluates a string of JavaScript code in the context of the specified object.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Object.observe()")}}</td>
+   <td>Asynchronously observing the changes to an object.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Object.unobserve()")}}</td>
+   <td>Remove observers.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Object.getNotifier()")}}</td>
+   <td>Creates an object that allows to synthetically trigger a change.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="Function">Function</h3>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Property</th>
+   <th>Description</th>
+  </tr>
+  <tr>
+   <td>{{jsxref("Global_Objects/Function/arity", "arity")}}</td>
+   <td>Number of formal arguments.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="Array">Array</h3>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td>Property</td>
+   <td>Description</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Array.observe()")}}</td>
+   <td>Asynchronously observing changes to Arrays.</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Array.unobserve()")}}</td>
+   <td>Remove observers.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="Number">Number</h3>
+
+<ul>
+ <li>{{jsxref("Number.toInteger()")}}</li>
+</ul>
+
+<h3 id="ParallelArray">ParallelArray</h3>
+
+<ul>
+ <li>{{jsxref("ParallelArray")}}</li>
+</ul>
+
+<h3 id="Statements">Statements</h3>
+
+<ul>
+ <li>{{jsxref("Statements/for_each...in", "for each...in")}} is deprecated. Use {{jsxref("Statements/for...of", "for...of")}} instead.</li>
+ <li>Destructuring {{jsxref("Statements/for...in", "for...in")}} is deprecated. Use {{jsxref("Statements/for...of", "for...of")}} instead.</li>
+</ul>
+
+<h3 id="E4X">E4X</h3>
+
+<p>See <a href="/en-US/docs/Archive/Web/E4X">E4X</a> for more information.</p>
+
+<h3 id="Sharp_variables">Sharp variables</h3>
+
+<p>See <a href="/en-US/docs/Archive/Web/Sharp_variables_in_JavaScript">Sharp variables in JavaScript</a> for more information.</p>
diff --git a/files/pt-br/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html b/files/pt-br/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html
new file mode 100644
index 0000000000..0b0aa34421
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/cant_access_lexical_declaration_before_init/index.html
@@ -0,0 +1,61 @@
+---
+title: 'ReferenceError: can''t access lexical declaration`X'' before initialization'
+slug: Web/JavaScript/Reference/Errors/Cant_access_lexical_declaration_before_init
+tags:
+  - Erros
+  - JavaScript
+  - ReferenceError
+translation_of: Web/JavaScript/Reference/Errors/Cant_access_lexical_declaration_before_init
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">ReferenceError: Use before delaration (Edge)
+ReferenceError: can't access lexical declaration `X' before initialization (Firefox)
+ReferenceError: 'x' is not defined (Chrome)
+</pre>
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>{{jsxref("ReferenceError")}}</p>
+
+<h2 id="O_que_está_errado">O  que está errado:</h2>
+
+<p>Uma variável léxica foi acessada antes de ser inicializada. Isso acontece dentro de qualquer declaração de bloco, quando as declarações <code>let</code> ou <code>const</code> são acessadas antes de serem definidas.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Errado">Errado</h3>
+
+<p>Neste caso, a variável "foo" é redeclarada usando <code>let</code>.</p>
+
+<pre class="brush: js example-bad">function test() {
+  let foo = 33;
+  if (true) {
+    let foo = (foo + 55);
+    // ReferenceError: can't access lexical
+    // declaration `foo' before initialization
+  }
+}
+test();
+</pre>
+
+<h3 id="Certo">Certo</h3>
+
+<p>Para mudar "foo" dentro do bloco if você precisa remover o <code>let</code> que causa a redeclaração.</p>
+
+<pre class="brush: js example-good">function test(){
+   let foo = 33;
+   if (true) {
+      foo = (foo + 55);
+   }
+}
+test();
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/let#Temporal_Dead_Zone_and_errors_with_let">Temporal Dead Zone e erros com let.</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/cant_access_property/index.html b/files/pt-br/web/javascript/reference/errors/cant_access_property/index.html
new file mode 100644
index 0000000000..7c5c9affa3
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/cant_access_property/index.html
@@ -0,0 +1,60 @@
+---
+title: 'TypeError: can''t access property "x" of "y"'
+slug: Web/JavaScript/Reference/Errors/Cant_access_property
+tags:
+  - Erros
+  - JavaScript
+  - TypeError
+translation_of: Web/JavaScript/Reference/Errors/Cant_access_property
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">TypeError: Unable to get property {x} of undefined or null reference (Edge)
+TypeError: can't access property {x} of {y} (Firefox)
+TypeError: {y} is undefined, can't access property {x} of it (Firefox)
+TypeError: {y} is null, can't access property {x} of it (Firefox)
+
+Exemplos:
+TypeError: x is undefined, can't access property "prop" of it
+TypeError: x is null, can't access property "prop" of it
+TypeError: can't access property "prop" of undefined
+TypeError: can't access property "prop" of null
+</pre>
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>{{jsxref("TypeError")}}.</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>O acesso a propriedade foi realizado com um valor {{jsxref("undefined")}} ou {{jsxref("null")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Casos_inválidos">Casos inválidos</h3>
+
+<pre class="brush: js example-bad">// casos undefined e null, onde o metódo substring não irá funcionar
+
+var foo = undefined;
+foo.substring(1); // TypeError: x is undefined, can't access property "substring" of it
+
+var foo = null;
+foo.substring(1); // TypeError: x is null, can't access property "substring" of it
+</pre>
+
+<h3 id="Corrigindo_o_problema">Corrigindo o problema</h3>
+
+<p>Para corrigir o problema de valores <code>undefined</code> ou <code>null</code>,  você pode usar o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a>, como no exemplo abaixo.</p>
+
+<pre class="brush: js">if (typeof foo !== 'undefined') {
+  // Agora que sabemos que <em>foo</em> está definida, podemos prosseguir
+}</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("undefined")}}</li>
+ <li>{{jsxref("null")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/fata_parênteses_após_lista_argumento/index.html b/files/pt-br/web/javascript/reference/errors/fata_parênteses_após_lista_argumento/index.html
new file mode 100644
index 0000000000..83844d17b5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/fata_parênteses_após_lista_argumento/index.html
@@ -0,0 +1,38 @@
+---
+title: Erro de sintaxe falta ) depois da lista de argumentos
+slug: Web/JavaScript/Reference/Errors/Fata_parênteses_após_lista_argumento
+translation_of: Web/JavaScript/Reference/Errors/Missing_parenthesis_after_argument_list
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">Erro de sintaxe: Falta ) depois da lista de argumento
+</pre>
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>{{jsxref("Erro de sintaxe")}}.</p>
+
+<h2 id="O_que_houve_de_errado">O que houve de errado?</h2>
+
+<p>Ocorreu um erro quando a função foi chamada. Pode ter sido um erro de escrita, falta de operador, ou uma string fora das aspas, por exemplo.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Pela falta do operador "+" para fazer a concatenação da string, o JavaScript esperou um argumento para a função log ser "PI: ". Nesse caso, deveria ser finalizado com parênteses de fechamento ')'.</p>
+
+<pre class="brush: js example-bad">console.log("PI: " Math.PI);
+// SyntaxError: missing ) after argument list
+</pre>
+
+<p>Você pode corrigir a chamada do log adicionand o operador "+":</p>
+
+<pre class="brush: js example-good">console.log("PI: " + Math.PI);
+// "PI: 3.141592653589793"</pre>
+
+<h2 id="Veja_também">Veja também:</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Functions">Funções</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/fecha_chaves_esquecida_apos_lista_propriedades/index.html b/files/pt-br/web/javascript/reference/errors/fecha_chaves_esquecida_apos_lista_propriedades/index.html
new file mode 100644
index 0000000000..b10562516e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/fecha_chaves_esquecida_apos_lista_propriedades/index.html
@@ -0,0 +1,52 @@
+---
+title: 'SyntaxError: missing } after property list'
+slug: Web/JavaScript/Reference/Errors/Fecha_chaves_esquecida_apos_lista_propriedades
+tags:
+  - Erro de Sintaxe
+  - Erros
+  - JavaScript
+  - SyntaxError
+translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_property_list
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">SyntaxError: missing } after property list
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Aconteceu um engano na sintaxe do <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">inicializador do objeto</a> em algum lugar. Pode ser que você esqueceu de colocar uma chave, mas também pode ser uma vírgula que foi esquecida, por exemplo. Verifique também se alguma chave de finalização ou parêntesis estão em algum lugar que não deveriam estar. Indente ou formate o código de uma maneira legível pode te ajudar a enxergar no meio dessa selva.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Vírgula_esquecida">Vírgula esquecida</h3>
+
+<p>Muitas vezes esquecemos uma vígula no inicializador de objeto:</p>
+
+<pre class="brush: js example-bad">var obj = {
+  a: 1,
+  b: { minhaProp: 2 }
+  c: 3
+};
+</pre>
+
+<p>O código correto deve ser:</p>
+
+<pre class="brush: js example-good">var obj = {
+  a: 1,
+  b: { minhaProp: 2 },
+  c: 3
+};
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Inicializador de objeto</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html b/files/pt-br/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html
new file mode 100644
index 0000000000..c48e8a8294
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/for-each-in_loops_are_deprecated/index.html
@@ -0,0 +1,169 @@
+---
+title: 'Warning: JavaScript 1.6''s for-each-in loops are deprecated'
+slug: Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated
+tags:
+  - Aviso
+  - JavaScript
+  - Warning
+translation_of: Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">Warning: JavaScript 1.6's for-each-in loops are deprecated; consider using ES6 for-of instead
+</pre>
+
+<h2 id="Tipo_de_mensagem">Tipo de mensagem</h2>
+
+<p>Warning</p>
+
+<h2 id="O_que_aconteceu_de_errado">O que aconteceu de errado?</h2>
+
+<p>A declaração {{jsxref("Statements/for_each...in", "for each (variable in obj)")}} do JavaScript 1.6 foi descontinuada e será removida num futuro próximo.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Iteração_do_objeto">Iteração do objeto</h3>
+
+<p>{{jsxref("Statements/for_each...in", "for each...in")}} tem sido usada para iterar por valores específicos do objeto.</p>
+
+<h4 id="Sintaxe_descontinuada">Sintaxe descontinuada</h4>
+
+<pre class="brush: js example-bad">var object = { a: 10, b: 20 };
+
+for each (var x in object) {
+  console.log(x);        // 10
+                         // 20
+}
+</pre>
+
+<h4 id="Sintaxe_padrão_alternativa">Sintaxe padrão alternativa</h4>
+
+<p>Agora você pode utilizar o loop padrão {{jsxref("Statements/for...in", "for...in")}}, para iterar sobre chaves específicas do objeto e receber cada valor para dentro do loop:</p>
+
+<pre class="brush: js example-good">var object = { a: 10, b: 20 };
+
+for (var key in object) {
+  var x = object[key];
+  console.log(x);        // 10
+                         // 20
+}
+</pre>
+
+<p>Ou, utilizando {{jsxref("Statements/for...of", "for...of")}} (ES2015) e {{jsxref("Object.values")}} (ES2017), você pode ter um array dos valores específicos do objeto e iterar sobre o array da seguinte maneira:</p>
+
+<pre class="brush: js example-good">var object = { a: 10, b: 20 };
+
+for (var x of Object.values(object)) {
+  console.log(x);        // 10
+                         // 20
+}
+</pre>
+
+<h3 id="Iteração_sobre_o_Array">Iteração sobre o Array</h3>
+
+<p>{{jsxref("Statements/for_each...in", "for each...in")}} tem sido usado para iterar sobre elementos específicos do array.</p>
+
+<h4 id="Sintaxe_descontinuada_2">Sintaxe descontinuada</h4>
+
+<pre class="brush: js example-bad">var array = [10, 20, 30];
+
+for each (var x in array) {
+  console.log(x);        // 10
+                         // 20
+                         // 30
+}
+</pre>
+
+<h4 id="Sintaxe_padrão_alternativa_2">Sintaxe padrão alternativa</h4>
+
+<p>Isso agora é possível também com loops {{jsxref("Statements/for...of", "for...of")}} (ES2015).</p>
+
+<pre class="brush: js example-good">var array = [10, 20, 30];
+
+for (var x of array) {
+  console.log(x);        // 10
+                         // 20
+                         // 30
+}
+</pre>
+
+<h3 id="Iterando_sobre_um_array_null-able">Iterando sobre um array null-able</h3>
+
+<p>{{jsxref("Statements/for_each...in", "for each...in")}} não faz nada se o valor especificado for <code>null</code> ou <code>undefined</code>, mas {{jsxref("Statements/for...of", "for...of")}} vai disparar uma exceção nestes casos.</p>
+
+<h4 id="Sintaxe_descontinuada_3">Sintaxe descontinuada</h4>
+
+<pre class="brush: js example-bad">function func(array) {
+  for each (var x in array) {
+    console.log(x);
+  }
+}
+func([10, 20]);        // 10
+                       // 20
+func(null);            // prints nothing
+func(undefined);       // prints nothing
+</pre>
+
+<h4 id="Sintaxe_padrão_alternativa_3">Sintaxe padrão alternativa</h4>
+
+<p>Para reescrever as declarações {{jsxref("Statements/for_each...in", "for each...in")}} de modo que os valores possam ser <code>null</code> ou <code>undefined</code> com {{jsxref("Statements/for...of", "for...of")}} também, você precisa utilizar algo como {{jsxref("Statements/for...of", "for...of")}}.</p>
+
+<pre class="brush: js example-good">function func(array) {
+  if (array) {
+    for (var x of array) {
+      console.log(x);
+    }
+  }
+}
+func([10, 20]);        // 10
+                       // 20
+func(null);            // prints nothing
+func(undefined);       // prints nothing
+</pre>
+
+<h3 id="Iterando_sobre_um_par_chave-valor_de_um_objeto">Iterando sobre um par chave-valor de um objeto</h3>
+
+<h4 id="Sintaxe_descontinuada_4">Sintaxe descontinuada</h4>
+
+<p>Existe um idioma descontinuado para iterar sobre pares chave-valor específicos de um objeto, utilizando {{jsxref("Statements/for_each...in", "for each...in")}} e o objeto descontinuado {{jsxref("Iterator")}}.</p>
+
+<pre class="brush: js example-bad">var object = { a: 10, b: 20 };
+
+for each (var [key, value] in Iterator(object)) {
+  console.log(key, value);  // "a", 10
+                            // "b", 20
+}
+</pre>
+
+<h4 id="Sintaxe_padrão_alternativa_4">Sintaxe padrão alternativa</h4>
+
+<p>Você pode utilizar agora o loop padrão {{jsxref("Statements/for...in", "for...in")}} para iterar sobre chaves específicas do objeto, e obter cada valor dentro do loop:</p>
+
+<pre class="brush: js example-good">var object = { a: 10, b: 20 };
+
+for (var key in object) {
+  var value = object[key];
+  console.log(key, value);  // "a", 10
+                            // "b", 20
+}
+</pre>
+
+<p>Ou utilizando {{jsxref("Statements/for...of", "for...of")}} (ES2015) e {{jsxref("Object.entries")}} (ES2017), você pode obter um array dos valores específicos do objeto e iterar sobre este array da seguinte maneira:</p>
+
+<pre class="brush: js example-good">var object = { a: 10, b: 20 };
+
+for (var [key, value] of Object.entries(object)) {
+  console.log(key, value);  // "a", 10
+                            // "b", 20
+}
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/for...of", "for...of")}}</li>
+ <li>{{jsxref("Object.values")}}</li>
+ <li>{{jsxref("Object.entries")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/illegal_character/index.html b/files/pt-br/web/javascript/reference/errors/illegal_character/index.html
new file mode 100644
index 0000000000..c36124dc8d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/illegal_character/index.html
@@ -0,0 +1,77 @@
+---
+title: 'SyntaxError: illegal character'
+slug: Web/JavaScript/Reference/Errors/Illegal_character
+tags:
+  - Erro
+  - ErroSintaxe
+  - ErrodeSintaxe
+  - Erros
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Errors/Illegal_character
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">SyntaxError: Invalid character (Edge)
+SyntaxError: illegal character (Firefox)
+SyntaxError: Invalid or unexpected token (Chrome)
+</pre>
+
+<h2 id="Tipo_do_erro">Tipo do erro</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Há um token inválido ou inesperado que não pertence a esta posição no código. Utilize um editor que realce a sintaxe e cuidadosamente verifique seu código em relação a desajustes como um sinal de menos (<code> - </code>) no lugar de um travessão (<code> – </code>) ou aspas simples (<code> " </code>) no lugar de aspas não padronizadas(<code> “ </code>).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Caracteres_desajustados">Caracteres desajustados</h3>
+
+<p>Alguns carateres parecem similares, mas irão impedir que o analisador interprete seu código. Exemplos famosos disso são as aspas, o sinal de menos ou o ponto e vírgula (o <a href="https://en.wikipedia.org/wiki/Question_mark#Greek_question_mark">ponto de interrogação grego (U+37e)</a> é quase igual)</p>
+
+<pre class="brush: js example-bad">“Isso parece uma string”;
+// SyntaxError: illegal character
+
+42 – 13;
+// SyntaxError: illegal character
+</pre>
+
+<p>Isto deve funcionar:</p>
+
+<pre class="brush: js example-good">"Isso é realmente uma string";
+
+42 - 13;
+</pre>
+
+<h3 id="Caracteres_esquecidos">Caracteres esquecidos</h3>
+
+<p>É fácil esquecer um caractere aqui ou ali.</p>
+
+<pre class="brush: js example-bad">var colors = ['#000', #333', '#666'];
+// SyntaxError: illegal character
+</pre>
+
+<p>Adicione as aspas que faltam no <code><strong>'</strong>#333'</code>.</p>
+
+<pre class="brush: js example-good">var colors = ['#000', '#333', '#666'];</pre>
+
+<h3 id="Caracteres_escondidos">Caracteres escondidos</h3>
+
+<p>Quando copiamos e colamos código de fontes externas, pode haver caracteres inválidos. Cuidado!</p>
+
+<pre class="brush: js example-bad">var foo = 'bar';​
+// SyntaxError: illegal character
+</pre>
+
+<p>Quando inspeciona-se este código em um editor como o Vim, você pode ver que, na verdade, há um caractere <a href="https://en.wikipedia.org/wiki/Zero-width_space">zero-width space (ZWSP) (U+200B)</a>.</p>
+
+<pre class="brush: js">var foo = 'bar';​&lt;200b&gt;</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">Lexical grammar</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/index.html b/files/pt-br/web/javascript/reference/errors/index.html
new file mode 100644
index 0000000000..2df10baf6e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/index.html
@@ -0,0 +1,14 @@
+---
+title: JavaScript error reference
+slug: Web/JavaScript/Reference/Errors
+tags:
+  - JavaScript
+  - NeedsTranslation
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Errors
+---
+<p>{{jsSidebar("Errors")}}</p>
+
+<p>Lista de erros "globais".</p>
+
+<p>{{ListSubPages("/pt-BR/docs/Web/JavaScript/Reference/Errors")}}</p>
diff --git a/files/pt-br/web/javascript/reference/errors/invalid_array_length/index.html b/files/pt-br/web/javascript/reference/errors/invalid_array_length/index.html
new file mode 100644
index 0000000000..fc520f9bea
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/invalid_array_length/index.html
@@ -0,0 +1,78 @@
+---
+title: 'RangeError: invalid array length'
+slug: Web/JavaScript/Reference/Errors/Invalid_array_length
+tags:
+  - Errors
+  - Erros
+  - JavaScript
+  - RangeError
+translation_of: Web/JavaScript/Reference/Errors/Invalid_array_length
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">RangeError: invalid array length (Firefox)
+RangeError: Invalid array length (Chrome)
+RangeError: Invalid array buffer length (Chrome)
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("RangeError")}}</p>
+
+<h2 id="O_que_houve_de_errado">O que houve de errado?</h2>
+
+<p>Um comprimento inválido de array pode aparecer nas seguintes situações:</p>
+
+<ul>
+ <li>Quando criamos um {{jsxref("Array")}} ou um {{jsxref("ArrayBuffer")}} que tem um comprimento que ou é negativo ou é maior ou igual a 2<sup>32</sup>, ou</li>
+ <li>quando configuramos a propriedade {{jsxref("Array.length")}} a um valor que é negativo, ou maior ou igual a 2<sup>32</sup>.</li>
+</ul>
+
+<p>Porque <code>Array</code> e <code>ArrayBuffer</code> tem um comprimento limitado? A propriedade <code>length</code> de um <code>Array</code> ou um <code>ArrayBuffer</code> é representado por um inteiro 32-bit unsigned, que pode apenas armazenar valores que estão no intervalo de 0 a 2<sup>32</sup>-1.</p>
+
+<p>Se você está criando um <code>Array</code>, utilizando o construtor, você provavelmente quer usar a notação literal, onde o primeiro argumento é interpretado como o comprimento do <code>Array</code>.</p>
+
+<p>Ao contrário, você poderia querer travar o comprimento antes de ajustar a propriedade do comprimento, ou utilizá-lo com um argumento do construtor.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Casos_inválidos">Casos inválidos</h3>
+
+<pre class="brush: js example-bad">new Array(Math.pow(2, 40))
+new Array(-1)
+new ArrayBuffer(Math.pow(2, 32))
+new ArrayBuffer(-1)
+
+let a = [];
+a.length = a.length - 1;         // define -1 à propriedade length
+
+let b = new Array(Math.pow(2, 32) - 1);
+b.length = b.length + 1;         // define 2^32 à propriedade length
+</pre>
+
+<h3 id="Casos_válidos">Casos válidos</h3>
+
+<pre class="brush: js example-good">[ Math.pow(2, 40) ]                     // [ 1099511627776 ]
+[ -1 ]                                  // [ -1 ]
+new ArrayBuffer(Math.pow(2, 32) - 1)
+new ArrayBuffer(0)
+
+let a = [];
+a.length = Math.max(0, a.length - 1);
+
+let b = new Array(Math.pow(2, 32) - 1);
+b.length = Math.min(0xffffffff, b.length + 1);
+
+// 0xffffffff é a notação hexadecimal de 2^32 - 1
+// que também pode ser escrito como (-1 &gt;&gt;&gt; 0)
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+ <li>{{jsxref("Array.length")}}</li>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html b/files/pt-br/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html
new file mode 100644
index 0000000000..9b15ff4bf9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/invalid_assignment_left-hand_side/index.html
@@ -0,0 +1,50 @@
+---
+title: 'ReferenceError: invalid assignment left-hand side'
+slug: Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side
+translation_of: Web/JavaScript/Reference/Errors/Invalid_assignment_left-hand_side
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">ReferenceError: invalid assignment left-hand side
+</pre>
+
+<h2 id="Tipo_do_erro">Tipo do erro</h2>
+
+<p>{{jsxref("ReferenceError")}}.</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Ouve uma declaração inesperada em algum lugar. Isso pode ocorrer devido a uma confusão entre um  <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operador de atribuição</a> e um <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Operador de comparação</a>, por exemplo. Enquanto um <code>"="</code> define uma variavel, <code>"=="</code> ou <code>"==="</code> são usados para fazer uma comparação entre valores.</p>
+
+<h2 id="Exemplos"> Exemplos</h2>
+
+<pre class="brush: js example-bad">if (Math.PI = 3 || Math.PI = 4) {
+  console.log('de modo algum!');
+}
+// ReferenceError: invalid assignment left-hand side
+
+var str = 'Olá, '
++= 'sou eu '
++= 'que você está procurando?';
+// ReferenceError: invalid assignment left-hand side
+</pre>
+
+<p>Na declaração <code>if</code> você deve usar um operador de comparação ("=="), e para a  atribuição da string, apenas o operador mais ("+") é necessario</p>
+
+<pre class="brush: js example-good">if (Math.PI == 3 || Math.PI == 4) {
+  console.log('de modo algum!');
+}
+
+var str = 'Olá, '
++ 'do '
++ 'outro lado!';
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li> <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operadores de atribuição</a></li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">Operadores de comparação</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/invalid_const_assignment/index.html b/files/pt-br/web/javascript/reference/errors/invalid_const_assignment/index.html
new file mode 100644
index 0000000000..cc5a4733a4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/invalid_const_assignment/index.html
@@ -0,0 +1,91 @@
+---
+title: 'TypeError: atribuição inválida para const "x"'
+slug: Web/JavaScript/Reference/Errors/Invalid_const_assignment
+tags:
+  - Erro
+  - JavaScript
+  - TypeError
+translation_of: Web/JavaScript/Reference/Errors/Invalid_const_assignment
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">TypeError: invalid assignment to const "x" (Firefox)
+TypeError: Assignment to constant variable. (Chrome)
+TypeError: Assignment to const (Edge)
+TypeError: Redeclaration of const 'x' (IE)
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("TypeError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Uma constante é um valor que não pode ser alterado pelo programa durante a execução normal. Ele não pode mudar através de reatribuição e não pode ser redeclarado. Em JavaScript, as constantes são declaradas usando a palavra-chave <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a></code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Redeclaração_inválida">Redeclaração inválida</h3>
+
+<p>Atribuir um valor ao mesmo nome de constante no mesmo escopo de bloco lançará o erro.</p>
+
+<pre class="brush: js example-bad">const COLUNAS = 80;
+
+// ...
+
+COLUNAS = 120; // TypeError: invalid assignment to const `COLUNAS'</pre>
+
+<h3 id="Corrigindo_o_erro">Corrigindo o erro</h3>
+
+<p>Existem várias opções para corrigir esse erro. Verifique o que se pretendia alcançar com a constante em questão.</p>
+
+<h4 id="Renomear">Renomear</h4>
+
+<p>Se você quis declarar outra constante, escolha outro nome e renomeie. Esse nome de constante já está sendo usado nesse escopo.</p>
+
+<pre class="brush: js example-good">const COLUNAS = 80;
+const COLUNAS_LARGAS = 120;</pre>
+
+<h4 id="const_let_ou_var"><code>const</code>, <code>let</code> ou <code>var</code>?</h4>
+
+<p>Não use const se você não quis declarar uma constante. Talvez você quisesse declarar uma variável com escopo de bloco com <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code> ou uma variável global com <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code>.</p>
+
+<pre class="brush: js example-good">let colunas = 80;
+
+// ...
+
+let colunas = 120;
+</pre>
+
+<h4 id="Escopo">Escopo</h4>
+
+<p>Verifique se você está no escopo correto. Essa constante deve aparecer nesse escopo ou deveria aparecer em uma função, por exemplo?</p>
+
+<pre class="brush: js example-good">const COLUNAS = 80;
+
+function configurarAmbienteTelaGrande() {
+  const COLUNAS = 120;
+}</pre>
+
+<h3 id="const_e_imutabilidade"><code>const</code> e imutabilidade</h3>
+
+<p>A declaração <code>const</code> cria uma referência somente leitura para um valor. Isso <strong>não significa</strong> que o valor que ela contém é imutável, apenas que o identificador da variável não pode ser reatribuído. Por exemplo, caso o conteúdo seja um objeto, isso significa que o objeto em si ainda pode ser alterado. Isso significa que você não pode alterar o valor armazenado em uma variável:</p>
+
+<pre class="brush: js example-bad">const obj = {foo: 'bar'};
+obj = {foo: 'baz'}; // TypeError: invalid assignment to const `obj'
+</pre>
+
+<p>Mas você pode alterar as propriedades em uma variável:</p>
+
+<pre class="brush: js example-good">obj.foo = 'baz';
+obj; // Object { foo: "baz" }</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a></code></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/invalid_date/index.html b/files/pt-br/web/javascript/reference/errors/invalid_date/index.html
new file mode 100644
index 0000000000..8663f67051
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/invalid_date/index.html
@@ -0,0 +1,55 @@
+---
+title: 'RangeError: invalid date'
+slug: Web/JavaScript/Reference/Errors/Invalid_date
+tags:
+  - Errors
+  - Erros
+  - JavaScript
+  - RangeError
+translation_of: Web/JavaScript/Reference/Errors/Invalid_date
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">RangeError: invalid date (Firefox)
+RangeError: invalid time value (Chrome)
+RangeError: Provided date is not in valid range (Chrome)
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("RangeError")}}</p>
+
+<h2 id="O_que_houve_de_errado">O que houve de errado?</h2>
+
+<p>Uma string apontando para uma data inválida foi disponibilizada para {{jsxref("Date")}} ou {{jsxref("Date.parse()")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Casos_inválidos">Casos inválidos</h3>
+
+<p>Strings irreconhecíveis ou data contendo elementos de strings formatadas com valores ISO ilegais, geralmente retornam  {{jsxref("NaN")}}. No entanto, dependendo da implementação, strings com formatos em não conformidade ISO, também podem disparar <code>RangeError: invalid date</code>, como os seguintes casos no Firefox:</p>
+
+<pre class="brush: js example-bad">new Date('foo-bar 2014');
+new Date('2014-25-23').toISOString();
+new Date('foo-bar 2014').toString();
+</pre>
+
+<p>Isto, no entanto, retorna {{jsxref("NaN")}} no Firefox:</p>
+
+<pre class="brush: js example-bad">Date.parse('foo-bar 2014'); // NaN</pre>
+
+<p>Para mais detalhes, veja a documentação {{jsxref("Date.parse()")}}.</p>
+
+<h3 id="Casos_válidos">Casos válidos</h3>
+
+<pre class="brush: js example-good">new Date('05 October 2011 14:48 UTC');</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date")}}</li>
+ <li>{{jsxref("Date.prototype.parse()")}}</li>
+ <li>{{jsxref("Date.prototype.toISOString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/json_bad_parse/index.html b/files/pt-br/web/javascript/reference/errors/json_bad_parse/index.html
new file mode 100644
index 0000000000..e3d389d2f8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/json_bad_parse/index.html
@@ -0,0 +1,105 @@
+---
+title: 'SyntaxError: JSON.parse: bad parsing'
+slug: Web/JavaScript/Reference/Errors/JSON_bad_parse
+translation_of: Web/JavaScript/Reference/Errors/JSON_bad_parse
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">SyntaxError: JSON.parse: unterminated string literal
+SyntaxError: JSON.parse: bad control character in string literal
+SyntaxError: JSON.parse: bad character in string literal
+SyntaxError: JSON.parse: bad Unicode escape
+SyntaxError: JSON.parse: bad escape character
+SyntaxError: JSON.parse: unterminated string
+SyntaxError: JSON.parse: no number after minus sign
+SyntaxError: JSON.parse: unexpected non-digit
+SyntaxError: JSON.parse: missing digits after decimal point
+SyntaxError: JSON.parse: unterminated fractional number
+SyntaxError: JSON.parse: missing digits after exponent indicator
+SyntaxError: JSON.parse: missing digits after exponent sign
+SyntaxError: JSON.parse: exponent part is missing a number
+SyntaxError: JSON.parse: unexpected end of data
+SyntaxError: JSON.parse: unexpected keyword
+SyntaxError: JSON.parse: unexpected character
+SyntaxError: JSON.parse: end of data while reading object contents
+SyntaxError: JSON.parse: expected property name or '}'
+SyntaxError: JSON.parse: end of data when ',' or ']' was expected
+SyntaxError: JSON.parse: expected ',' or ']' after array element
+SyntaxError: JSON.parse: end of data when property name was expected
+SyntaxError: JSON.parse: expected double-quoted property name
+SyntaxError: JSON.parse: end of data after property name when ':' was expected
+SyntaxError: JSON.parse: expected ':' after property name in object
+SyntaxError: JSON.parse: end of data after property value in object
+SyntaxError: JSON.parse: expected ',' or '}' after property value in object
+SyntaxError: JSON.parse: expected ',' or '}' after property-value pair in object literal
+SyntaxError: JSON.parse: property names must be double-quoted strings
+SyntaxError: JSON.parse: expected property name or '}'
+SyntaxError: JSON.parse: unexpected character
+SyntaxError: JSON.parse: unexpected non-whitespace character after JSON data
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="O_que_ocorreu_de_errado">O que ocorreu de errado?</h2>
+
+<p>{{jsxref("JSON.parse()")}} converte uma string para JSON. A string precisa ser um JSON válido e retornará esse erro caso a sintaxe esteja errada.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="JSON.parse()_não_permite_vírgulas_à_direita"><code>JSON.parse()</code> não permite vírgulas à direita</h3>
+
+<p>As duas linhas retornarão um SyntaxError:</p>
+
+<pre class="brush: js example-bad">JSON.parse('[1, 2, 3, 4,]');
+JSON.parse('{"foo": 1,}');
+// SyntaxError JSON.parse: unexpected character
+// at line 1 column 14 of the JSON data
+</pre>
+
+<p>Retire as virgulas sobrando para converter o JSON corretamente:</p>
+
+<pre class="brush: js example-good">JSON.parse('[1, 2, 3, 4]');
+JSON.parse('{"foo": 1}');</pre>
+
+<h3 id="Propriedades_precisão_ser_escritas_com_aspas_duplas">Propriedades precisão ser escritas com aspas duplas</h3>
+
+<p>Você não pode usar aspas simples em propriedades, exemplo: 'foo'.</p>
+
+<pre class="brush: js example-bad">JSON.parse("{'foo': 1}");
+// SyntaxError: JSON.parse: expected property name or '}'
+// at line 1 column 2 of the JSON data</pre>
+
+<p>Em vez disso use "foo":</p>
+
+<pre class="brush: js example-good">JSON.parse('{"foo": 1}');</pre>
+
+<h3 id="Zeros_à_esquerda_e_pontos_decimais">Zeros à esquerda e pontos decimais</h3>
+
+<p>Você não pode usar zeros à esquerda, como 01, e pontos decimais precisam ser seguidos de pelo menos um digito.</p>
+
+<pre class="brush: js example-bad">JSON.parse('{"foo": 01}');
+// SyntaxError: JSON.parse: expected ',' or '}' after property value
+// in object at line 1 column 2 of the JSON data
+
+JSON.parse('{"foo": 1.}');
+// SyntaxError: JSON.parse: unterminated fractional number
+// at line 1 column 2 of the JSON data
+</pre>
+
+<p>Em vez disso, use o 1 sem o zero, e pelo menos um digito após um ponto decimal:</p>
+
+<pre class="brush: js example-good">JSON.parse('{"foo": 1}');
+JSON.parse('{"foo": 1.0}');
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("JSON")}}</li>
+ <li>{{jsxref("JSON.parse()")}}</li>
+ <li>{{jsxref("JSON.stringify()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/missing_colon_after_property_id/index.html b/files/pt-br/web/javascript/reference/errors/missing_colon_after_property_id/index.html
new file mode 100644
index 0000000000..f235891169
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/missing_colon_after_property_id/index.html
@@ -0,0 +1,72 @@
+---
+title: 'Erro de Sintaxe: faltando : depois da propriedade id'
+slug: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id
+translation_of: Web/JavaScript/Reference/Errors/Missing_colon_after_property_id
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">SyntaxError: missing : after property id
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Ao criar objetos com a sintaxe do <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">iniciador do objeto</a>, dois pontos (<code>:</code>) separam chaves e valores para as propriedades do objeto.</p>
+
+<pre class="brush: js">var obj = { propertyKey: 'value' };
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Dois-pontos_contra_sinal_de_igualdade">Dois-pontos contra sinal de igualdade</h3>
+
+<p>Este código falha, pois o sinal de igualdade não pode ser usado dessa maneira nesta sintaxe do iniciador do objeto.</p>
+
+<pre class="brush: js example-bad">var obj = { propertyKey = 'value' };
+// SyntaxError: missing : after property id
+</pre>
+
+<p>Correto seria usar um dois-pontos, ou usar colchetes para atribuir uma nova propriedade depois que o objeto já foi criado.</p>
+
+<pre class="brush: js example-good">var obj = { propertyKey: 'value' };
+
+// or alternatively
+
+var obj = { };
+obj['propertyKey'] = 'value';
+</pre>
+
+<h3 id="Propriedades_vazia">Propriedades vazia</h3>
+
+<p>Você não pode criar propriedades vazias como esta:</p>
+
+<pre class="brush: js example-bad">var obj = { propertyKey; };
+// SyntaxError: missing : after property id
+</pre>
+
+<p>Se você precisa definir uma propriedade sem um valor, você pode usar {{jsxref("null")}} como um valor.</p>
+
+<pre class="brush: js example-good">var obj = { propertyKey: null };</pre>
+
+<h3 id="Propriedades_computadas">Propriedades computadas</h3>
+
+<p>Se você criar uma chave de propriedade de uma expressão, você precisa usar colchetes. Caso contrário, o nome da propriedade não pode ser computado:</p>
+
+<pre class="brush: js example-bad">var obj = { 'b'+'ar': 'foo' };
+// SyntaxError: missing : after property id
+</pre>
+
+<p>Coloque a expressão entre parênteses <code>[]</code>:</p>
+
+<pre class="brush: js example-good">var obj = { ['b'+'ar']: 'foo' };</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Inicializador de objeto</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/missing_curly_after_function_body/index.html b/files/pt-br/web/javascript/reference/errors/missing_curly_after_function_body/index.html
new file mode 100644
index 0000000000..b35ba4dfdf
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/missing_curly_after_function_body/index.html
@@ -0,0 +1,67 @@
+---
+title: 'SyntaxError: missing } after function body'
+slug: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body
+tags:
+  - PT
+translation_of: Web/JavaScript/Reference/Errors/Missing_curly_after_function_body
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<p>The JavaScript exception "missing } after function body" occurs when there is a syntax mistake when creating a function somewhere. Check if any closing curly brackets or parenthesis are in the correct order.</p>
+
+<h2 id="Message">Message</h2>
+
+<pre class="syntaxbox notranslate">SyntaxError: Expected '}' (Edge)
+SyntaxError: missing } after function body (Firefox)
+</pre>
+
+<h2 id="Error_type">Error type</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="What_went_wrong">What went wrong?</h2>
+
+<p>There is a syntax mistake when creating a function somewhere. Also check if any closing curly brackets or parenthesis are in the correct order. Indenting or formatting the code a bit nicer might also help you to see through the jungle.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Forgotten_closing_curly_bracket">Forgotten closing curly bracket</h3>
+
+<p>Oftentimes, there is a missing curly bracket in your function code:</p>
+
+<pre class="brush: js example-bad notranslate">var charge = function() {
+  if (sunny) {
+    useSolarCells();
+  } else {
+    promptBikeRide();
+};
+</pre>
+
+<p>Correct would be:</p>
+
+<pre class="brush: js example-good notranslate">var charge = function() {
+  if (sunny) {
+    useSolarCells();
+  } else {
+    promptBikeRide();
+  }
+};</pre>
+
+<p>It can be more obscure when using <a href="/en-US/docs/Glossary/IIFE">IIFE</a>, <a href="/en-US/docs/Web/JavaScript/Closures">Closures</a>, or other constructs that use a lot of different parenthesis and curly brackets, for example.</p>
+
+<pre class="brush: js example-bad notranslate">(function() { if (true) { return false; } );
+</pre>
+
+<p>Oftentimes, indenting differently or double checking indentation helps to spot these errors.</p>
+
+<pre class="brush: js example-good notranslate">(function() {
+  if (true) {
+    return false;
+  }
+});</pre>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Functions">Functions</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/missing_formal_parameter/index.html b/files/pt-br/web/javascript/reference/errors/missing_formal_parameter/index.html
new file mode 100644
index 0000000000..cedc5bb71a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/missing_formal_parameter/index.html
@@ -0,0 +1,80 @@
+---
+title: 'SyntaxError: missing formal parameter'
+slug: Web/JavaScript/Reference/Errors/Missing_formal_parameter
+tags:
+  - Erro
+  - Erros
+  - JavaScript
+  - SyntaxError
+translation_of: Web/JavaScript/Reference/Errors/Missing_formal_parameter
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">SyntaxError: missing formal parameter (Firefox)
+</pre>
+
+<h2 id="Tipo_de_error">Tipo de error</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>"Parâmetro Formal" é uma maneira elegante de dizer "parâmetro de função". Faltam parâmetros válidos em sua função. Na declaração de uma função os parâmetros devem ser {{Glossary("Identifier", "identifiers")}}, em vez de um valor como números, strings ou objetos. Declarar funções e chamar funções são dois passos diferentes. Declarações exigem identificadores como parâmetros e é apenas ao chamar (invocar) a função que você fornece os valores que a função deve usar.</p>
+
+<p>Em {{glossary("JavaScript")}}, identificadores podem obter apenas caracteres alfanuméricos (ou "$" e "_"), e não podem começar com um número. Um identificador difere de uma <strong>string</strong> porque uma string é um dado, enquanto que um identificador é parte do código.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Parâmetros de função devem ser identificadores ao se configurar uma função. Todas essas declarações de função abaixo falham, pois estão fornecendo valores para seus parâmetros:</p>
+
+<pre class="brush: js example-bad highlight:[1,6,11]">function quadrado(3) {
+  return numero * numero;
+};
+// SyntaxError: missing formal parameter
+
+function saudacao("Olá") {
+  return saudacao;
+};
+// SyntaxError: missing formal parameter
+
+function log({ obj: "valor"}) {
+  console.log(arg)
+};
+// SyntaxError: missing formal parameter
+</pre>
+
+<p>Você terá de usar identificadores nas declarações de função:</p>
+
+<pre class="brush: js example-good highlight:[1,5,9]">function quadrado(numero) {
+  return numero * numero;
+};
+
+function saudar(saudacao) {
+  return saudacao;
+};
+
+function log(arg) {
+  console.log(arg)
+};</pre>
+
+<p>You can then call these functions with the arguments you like:</p>
+
+<pre class="brush: js">quadrado(2); // 4
+
+saudar("Olá"); // "Olá"
+
+log({obj: "valor"}); // Object { obj: "valor" }
+</pre>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>Outros erros referentes a parâmetros formais:
+  <ul>
+   <li><a href="/en-US/docs/Web/JavaScript/Reference/Errors/Malformed_formal_parameter">SyntaxError: Parâmetro formal mal formado</a></li>
+   <li><a href="/en-US/docs/Web/JavaScript/Reference/Errors/Redeclared_parameter">SyntaxError: redeclaração de parâmetro formal "x"</a></li>
+  </ul>
+ </li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/missing_semicolon_before_statement/index.html b/files/pt-br/web/javascript/reference/errors/missing_semicolon_before_statement/index.html
new file mode 100644
index 0000000000..b44ca2aae6
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/missing_semicolon_before_statement/index.html
@@ -0,0 +1,63 @@
+---
+title: 'SyntaxError: missing ; before statement'
+slug: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement
+translation_of: Web/JavaScript/Reference/Errors/Missing_semicolon_before_statement
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Messagem">Messagem</h2>
+
+<pre class="syntaxbox">SyntaxError: falta ; antes da declaração
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("SyntaxError")}}.</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Falta um ponto-e-vírgula (<code>;</code>) em algum lugar. <a href="/en-US/docs/Web/JavaScript/Reference/Statements">JavaScript statements</a> must be terminated with semicolons. Some of them are affected by <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">automatic semicolon insertion (ASI)</a>, but in this case you need to provide a semicolon, so that JavaScript can parse the source code correctly.</p>
+
+<p>However, oftentimes, this error is only a consequence of another error, like not escaping strings properly, or using <code>var</code> wrongly. You might also have too many parenthesis somewhere. Carefully check the syntax when this error is thrown.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Unescaped_strings">Unescaped strings</h3>
+
+<p>This error can occur easily when not escaping strings properly and the JavaScript engine is expecting the end of your string already. For example:</p>
+
+<pre class="brush: js example-bad">var foo = 'Tom's bar';
+// SyntaxError: missing ; before statement</pre>
+
+<p>You can use double quotes, or escape the apostrophe:</p>
+
+<pre class="brush: js example-good">var foo = "Tom's bar";
+var foo = 'Tom\'s bar';
+</pre>
+
+<h3 id="Declaring_properties_with_var">Declaring properties with var</h3>
+
+<p>You <strong>cannot</strong> declare properties of an object or array with a <code>var</code> declaration.</p>
+
+<pre class="brush: js example-bad">var obj = {};
+var obj.foo = 'hi'; // SyntaxError missing ; before statement
+
+var array = [];
+var array[0] = 'there'; // SyntaxError missing ; before statement
+</pre>
+
+<p>Instead, omit the <code>var</code> keyword:</p>
+
+<pre class="brush: js example-good">var obj = {};
+obj.foo = 'hi';
+
+var array = [];
+array[0] = 'there';
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">Automatic semicolon insertion (ASI)</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements">JavaScript statements</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/negative_repetition_count/index.html b/files/pt-br/web/javascript/reference/errors/negative_repetition_count/index.html
new file mode 100644
index 0000000000..599e7e1271
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/negative_repetition_count/index.html
@@ -0,0 +1,45 @@
+---
+title: 'RangeError: repeat count must be non-negative'
+slug: Web/JavaScript/Reference/Errors/Negative_repetition_count
+tags:
+  - Erros
+  - JavaScript
+  - RangeError
+translation_of: Web/JavaScript/Reference/Errors/Negative_repetition_count
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">RangeError: argument out of range
+RangeError: repeat count must be non-negative (Firefox)
+RangeError: Invalid count value (Chrome)
+</pre>
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>{{jsxref("RangeError")}}</p>
+
+<h2 id="O_que_está_errado">O que está errado?</h2>
+
+<p>O método {{jsxref("String.prototype.repeat()")}} foi usado. Ele tem um parâmetro <code>count</code> indicando o número de vezes para repetir a string. Esse contador deve ser maior ou igual à 0 menor que  {{jsxref("Infinity")}} (infinito positivo). O intervalo de vaores permitidos pode ser descrito por:  [0, +∞).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Errado">Errado</h3>
+
+<pre class="brush: js example-bad">'abc'.repeat(-1); // RangeError </pre>
+
+<h3 id="Certo">Certo</h3>
+
+<pre class="brush: js example-good">'abc'.repeat(0);    // ''
+'abc'.repeat(1);    // 'abc'
+'abc'.repeat(2);    // 'abcabc'
+'abc'.repeat(3.5);  // 'abcabcabc' (count será convertido para inteiro)
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.repeat()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/no_variable_name/index.html b/files/pt-br/web/javascript/reference/errors/no_variable_name/index.html
new file mode 100644
index 0000000000..5e192a15a2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/no_variable_name/index.html
@@ -0,0 +1,79 @@
+---
+title: 'SyntaxError: missing variable name'
+slug: Web/JavaScript/Reference/Errors/No_variable_name
+translation_of: Web/JavaScript/Reference/Errors/No_variable_name
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">SyntaxError: missing variable name (Firefox)
+SyntaxError: Unexpected token = (Chrome)</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>O nome de uma variável está faltando. Isto é provavelmente devido a um erro de sintaxe no seu código. Provavelmente uma vírgula está errada em algum lugar. Totalmente compreensível! Nomear as coisas é tão difícil.</p>
+
+<h2 id="Examplos">Examplos</h2>
+
+<h3 id="Falta_um_nome_de_variável">Falta um nome de variável</h3>
+
+<pre class="brush: js example-bad">var = "foo";
+</pre>
+
+<p>É difícil chegar com bons nomes de variáveis. Nós todos estivemos lá.</p>
+
+<pre class="brush: js example-good">var ohGodWhy = "foo";</pre>
+
+<h3 id="Palavras-chave_reservadas_não_podem_ser_nomes_de_variáveis">Palavras-chave reservadas não podem ser nomes de variáveis</h3>
+
+<p>Existem alguns nomes de variáveis ​​que são palavras-chave resevadas. Você não pode usar isso. Desculpa :(</p>
+
+<pre class="brush: js example-bad">var debugger = "whoop";
+// SyntaxError: missing variable name
+</pre>
+
+<h3 id="Declarando_múltiplas_variáveis">Declarando múltiplas variáveis</h3>
+
+<p>Preste especial atenção às vírgulas ao declarar múltiplas variáveis. Existe um excesso de vírgula? Você acidentalmente adicionou vírgulas em vez de ponto e vírgula?</p>
+
+<pre class="brush: js example-bad">var x, y = "foo",
+var x, = "foo"
+
+var first = document.getElementById('one'),
+var second = document.getElementById('two'),
+
+// SyntaxError: missing variable name
+</pre>
+
+<p>A versão corrigida:</p>
+
+<pre class="brush: js example-good">var x, y = "foo";
+var x = "foo";
+
+var first = document.getElementById('one');
+var second = document.getElementById('two');</pre>
+
+<h3 id="Arrays">Arrays</h3>
+
+<p>{{jsxref("Array")}} literais em JavaScript precisam de colchetes ao redor dos valores. Isso não funcionará:</p>
+
+<pre class="brush: js example-bad">var arr = 1,2,3,4,5;
+// SyntaxError: missing variable name
+</pre>
+
+<p>Isso seria correto:</p>
+
+<pre class="brush: js example-good">var arr = [1,2,3,4,5];</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>Bons nomes de variáveis</li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li>
+ <li>Declarações de variáveis ​​no Guia JavaScript</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/not_a_codepoint/index.html b/files/pt-br/web/javascript/reference/errors/not_a_codepoint/index.html
new file mode 100644
index 0000000000..7e0c85bf8d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/not_a_codepoint/index.html
@@ -0,0 +1,56 @@
+---
+title: 'RangeError: argument is not a valid code point'
+slug: Web/JavaScript/Reference/Errors/Not_a_codepoint
+tags:
+  - Erros
+  - JavaScript
+  - RangeError
+translation_of: Web/JavaScript/Reference/Errors/Not_a_codepoint
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">RangeError: Invalid code point {0} (Edge)
+RangeError: {0} is not a valid code point (Firefox)
+RangeError: Invalid code point {0} (Chrome)
+</pre>
+
+
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>{{jsxref("RangeError")}}</p>
+
+<h2 id="O_que_está_errado">O que está errado?</h2>
+
+<p><span class="seoSummary">{{jsxref("String.fromCodePoint()")}} dispara esse erro quando são passados valores {{jsxref("NaN")}}, inteiros negativos (-1), não inteiros (5.4), ou valores maiores que 0x10FFFF (1114111).</span></p>
+
+<p>Um <a href="https://pt.wikipedia.org/wiki/Ponto_de_c%C3%B3digo">code point</a> é um valor Unicode; isto é,é um valor inteiro entre <code>0</code> e <code>0x10FFFF</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Errado">Errado</h3>
+
+<pre class="brush: js example-bad">String.fromCodePoint('_');      // RangeError
+String.fromCodePoint(Infinity); // RangeError
+String.fromCodePoint(-1);       // RangeError
+String.fromCodePoint(3.14);     // RangeError
+String.fromCodePoint(3e-2);     // RangeError
+String.fromCodePoint(NaN);      // RangeError</pre>
+
+<h3 id="Certo">Certo</h3>
+
+<pre class="brush: js example-good">String.fromCodePoint(42);       // "*"
+String.fromCodePoint(65, 90);   // "AZ"
+String.fromCodePoint(0x404);    // "\u0404"
+String.fromCodePoint(0x2F804);  // "\uD87E\uDC04"
+String.fromCodePoint(194564);   // "\uD87E\uDC04"
+String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07"
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.fromCodePoint()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/not_a_function/index.html b/files/pt-br/web/javascript/reference/errors/not_a_function/index.html
new file mode 100644
index 0000000000..c98e500583
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/not_a_function/index.html
@@ -0,0 +1,123 @@
+---
+title: 'TypeError: "x" is not a function'
+slug: Web/JavaScript/Reference/Errors/Not_a_function
+tags:
+  - Erros JavaScrip TypeError
+translation_of: Web/JavaScript/Reference/Errors/Not_a_function
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">TypeError: Object doesn't support property or method {x} (Edge)
+TypeError: "x" is not a function
+</pre>
+
+<h2 id="Tipo_do_erro">Tipo do erro</h2>
+
+<p>{{jsxref("TypeError")}}.</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Houve a tentativa de obter um valor de uma função, mas o valor não é exatamente uma função. Algum código espera que você forneça uma função, mas não foi o que acontenceu.</p>
+
+<p>Talvez exista um erro de digitação no nome da função? Talvez o objeto no qual você está chamando o método não tenha essa função? Por exemplo, objetos no JavaScript não tem a função <code>map</code>, mas o objeto Array tem.</p>
+
+<p>Existem várias funções internas que precisam de uma função (callback). Você terá que prover uma função para obter esses métodos funcionando corretamente:</p>
+
+<ul>
+ <li>Quando estiver trabalhando com os objetos {{jsxref("Array")}} ou {{jsxref("TypedArray")}}:
+  <ul>
+   <li>{{jsxref("Array.prototype.every()")}}, {{jsxref("Array.prototype.some()")}}, {{jsxref("Array.prototype.forEach()")}}, {{jsxref("Array.prototype.map()")}}, {{jsxref("Array.prototype.filter()")}},  {{jsxref("Array.prototype.reduce()")}}, {{jsxref("Array.prototype.reduceRight()")}}, {{jsxref("Array.prototype.find()")}}</li>
+  </ul>
+ </li>
+ <li>Quando estiver trabalhando com os objetos {{jsxref("Map")}} ou {{jsxref("Set")}}:
+  <ul>
+   <li>{{jsxref("Map.prototype.forEach()")}} e {{jsxref("Set.prototype.forEach()")}}</li>
+  </ul>
+ </li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Um_erro_de_digitação_no_nome_da_função">Um erro de digitação no nome da função</h3>
+
+<p>Nesse caso, que ocorre com bastante frequência, existe um erro de digitação no nome do método:</p>
+
+<pre class="brush: js example-bad">var x = document.getElementByID('foo');
+// TypeError: document.getElementByID is not a function
+</pre>
+
+<p>O nome correto da função é <code>getElementByI<strong>d</strong></code>:</p>
+
+<pre class="brush: js example-good">var x = document.getElementById('foo');
+</pre>
+
+<h3 id="Função_chamada_no_objeto_errado">Função chamada no objeto errado</h3>
+
+<p>Para alguns métodos, é necessário fornecer a função (callback) que irá funcionar apenas em objetos específicos. Nesse exemplo, é utilizado {{jsxref("Array.prototype.map()")}} que irá funcionar apenas em objetos {{jsxref("Array")}}.</p>
+
+<pre class="brush: js example-bad">var obj = {a: 13, b: 37, c: 42};
+
+obj.map(function(num) {
+  return num * 2;
+});
+
+// TypeError: obj.map is not a function</pre>
+
+<p>Ao invés disso, use uma array:</p>
+
+<pre class="brush: js example-good">var numbers = [1, 4, 9];
+
+numbers.map(function(num) {
+  return num * 2;
+});
+
+// Array [2, 8, 18]
+</pre>
+
+<h3 id="Função_compartilha_o_nome_com_uma_propriedade_pré-existente">Função compartilha o nome com uma propriedade pré-existente</h3>
+
+<p>Algumas vezes, ao criar uma classe, pode haver uma propriedade e função com os mesmos nomes. Ao chamar a função, o compilador não consegue identificar a função.</p>
+
+<pre class="brush: js example-bad">var Dog = function () {
+ this.age = 11;
+ this.color = "black";
+ this.name = "Ralph";
+ return this;
+}
+
+Dog.prototype.name = function(name) {
+ this.name = name;
+ return this;
+}
+
+
+var myNewDog = new Dog();
+myNewDog.name("Cassidy"); //Uncaught TypeError: myNewDog.name is not a function
+</pre>
+
+<p>Então, use um nome diferente para a propriedade</p>
+
+<pre class="brush: js example-good">var Dog = function () {
+ this.age = 11;
+ this.color = "black";
+ this.dogName = "Ralph"; //Using this.dogName instead of .name
+ return this;
+}
+
+Dog.prototype.name = function(name) {
+ this.dogName = name;
+ return this;
+}
+
+
+var myNewDog = new Dog();
+myNewDog.name("Cassidy"); //Dog { age: 11, color: 'black', dogName: 'Cassidy' }
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions">Funções</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/não_definido/index.html b/files/pt-br/web/javascript/reference/errors/não_definido/index.html
new file mode 100644
index 0000000000..6642b81b44
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/não_definido/index.html
@@ -0,0 +1,66 @@
+---
+title: 'ReferenceError: "x" não está definido'
+slug: Web/JavaScript/Reference/Errors/Não_definido
+translation_of: Web/JavaScript/Reference/Errors/Not_defined
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">ReferenceError: "x" is not defined
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("ReferenceError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Há uma variavel inexistente referenciada em algum lugar. Essa variável precisa ser declarada ou você precisa ter certeza que ela está disponível no seu atual script ou {{Glossary("escopo")}}.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> Quando carregar uma biblioteca (como o JQuery) tenha certeza que ela está carregada antes que você acesse as variáveis dela, como "$". Coloque na tag {{HTMLElement("script")}} para carregar a biblioteca antes do seu código usá-lo.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Variável_não_declarada">Variável não declarada</h3>
+
+<pre class="brush: js example-bad">foo.substring(1); // ReferenceError: foo is not defined
+</pre>
+
+<p>A variável "foo" não está definida em lugar nenhum. Ela precisa ser uma string e assim o método {{jsxref("String.prototype.substring()")}} irá funcionar.</p>
+
+<pre class="brush: js example-good">var foo = "bar";
+foo.substring(1); // "ar"</pre>
+
+<h3 id="Escopo_Errado">Escopo Errado</h3>
+
+<p><span style='font-family: "Calibri",sans-serif; font-size: 11.0pt; line-height: 107%;'>Uma variável precisa estar disponível no atual contexto de execução. Variáveis definidas dentro de uma </span> <a href="/en-US/docs/Web/JavaScript/Reference/Functions">function</a> <span style='font-family: "Calibri",sans-serif; font-size: 11.0pt; line-height: 107%;'>não podem ser acessadas de outros lugares fora da função, porque a variável é definida apenas no escopo da função</span></p>
+
+<pre class="brush: js example-bad">function numbers () {
+  var num1 = 2,
+      num2 = 3;
+  return num1 + num2;
+}
+
+console.log(num1); // ReferenceError num1 is not defined.</pre>
+
+<p>Entretanto, uma função pode acessar todas as variáveis e funções definidas dentro do escopo no qual elas estão definidas. Em outras palavras, uma função definida no escopo global pode acessar todas as variáveis no escopo global.</p>
+
+<pre class="brush: js example-good">var num1 = 2,
+    num2 = 3;
+
+function numbers () {
+  return num1 + num2;
+}
+
+console.log(num1); // 2</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{Glossary("Scope")}}</li>
+ <li><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Values,_variables,_and_literals">Declarando variáveis no JavaScript</a></li>
+ <li><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Fun%C3%A7%C3%B5es">Escopo de função no JavaScript</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/nãonomeado_funcão_declaração/index.html b/files/pt-br/web/javascript/reference/errors/nãonomeado_funcão_declaração/index.html
new file mode 100644
index 0000000000..6f01588059
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/nãonomeado_funcão_declaração/index.html
@@ -0,0 +1,116 @@
+---
+title: 'Erro de sintaxe: declaração de função requer um nome'
+slug: Web/JavaScript/Reference/Errors/NãoNomeado_funcão_declaração
+tags:
+  - Erro
+  - Erro de Sintaxe
+  - JavaScript
+  - Statement
+translation_of: Web/JavaScript/Reference/Errors/Unnamed_function_statement
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">Errodesintaxe: Identificador Esperado(Edge)
+Errodesintaxe: declaração de função requer um nome [Firefox]
+Errodesintaxe: Token inesperado ( [Chrome]
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("Errodesintaxe")}}</p>
+
+<h2 id="O_que_estava_errado">O que estava errado?</h2>
+
+<p>Existe uma declaração no código que requer um nome. Você precisa checar como as funções são definidas e se você precisa providenciar um nome, se a função em questão precisa ser uma expressão de função, um {{Glossary("IIFE")}} ou se o código da função está colocado corretamente neste contexto.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Statements_vs_expressions">Statements vs expressions</h3>
+
+<p>Uma  <em>declaração de função</em> (ou <em>declaração de função</em>) requer um nome, isso não vai funcionar:</p>
+
+<pre class="brush: js example-bad">function () {
+  return 'Olha mundo';
+}
+// SyntaxError: function statement requires a name
+</pre>
+
+<p>Você pode usar uma expressão de função ao invés de uma atribuição.</p>
+
+<pre class="brush: js example-good">var saudar = function() {
+  return 'Ola mundo';
+};</pre>
+
+<p>Ou, sua função pode ser pretendida a ser uma <a href="https://en.wikipedia.org/wiki/Immediately-invoked_function_expression">IIFE</a> (Immediately Invoked Function Expression), qual é uma função que será em breve definida. Você vai precisar de um pouco mais de colchetes neste caso:</p>
+
+<pre class="brush: js example-good">(function () {
+
+})();</pre>
+
+<h3 id="Funçoes_etiquetadas">Funçoes etiquetadas</h3>
+
+<p>Se usar <a href="/en-US/docs/Web/JavaScript/Reference/Statements/label">labels</a>, precisará providenciar um nome de função depois da  palavra <code>function</code> . Isto não funciona:</p>
+
+<pre class="brush: js example-bad">function Saudacao() {
+  alemao: function () {
+    return "Moin";
+  }
+}
+// SyntaxError: a função declaração requer um nome
+</pre>
+
+<p>Isso funciona ,veja o exemplo:</p>
+
+<pre class="brush: js example-good">function Saudacao() {
+  alemao: function g() {
+    return "Moin";
+  }
+}</pre>
+
+<h3 id="Métodos_de_Objetos">Métodos de Objetos</h3>
+
+<p>Se pretende criar um metodo para um objeto, voce precisa-rá criar um objeto (hehehe). A seguir uma sintaxe sem nome depois de <code>function</code> é válida.</p>
+
+<pre class="brush: js example-good">var saudacao = {
+  alemao: function () {
+    return "Moin";
+  }
+};</pre>
+
+<h3 id="Callback_Sintaxe">Callback Sintaxe</h3>
+
+<p>Alem disso,cheque sua sintaxe usando callbacks. Colchetes e virgulas ficam facilmente atrapalhar e dificultar.</p>
+
+<pre class="brush: js example-bad">promessa.then(
+  function() {
+    console.log("sucesso");
+  });
+  function() {
+    console.log("erro");
+}
+// SyntaxError: function statement requires a name
+</pre>
+
+<p>O correto seria:</p>
+
+<pre class="brush: json example-good">promise.then(
+  function() {
+    console.log("success");
+  },
+  function() {
+    console.log("error");
+  }
+);//sempre que abrir feche();
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Functions">Guia de funções em JavaScript</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">Funções de Declaração</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">Funções de Expressão</a></li>
+ <li><a href="https://en.wikipedia.org/wiki/Immediately-invoked_function_expression">Funções imediatas (IIFE)</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/label">Etiqueta</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/precision_range/index.html b/files/pt-br/web/javascript/reference/errors/precision_range/index.html
new file mode 100644
index 0000000000..b45da23806
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/precision_range/index.html
@@ -0,0 +1,101 @@
+---
+title: 'RangeError: precision is out of range'
+slug: Web/JavaScript/Reference/Errors/Precision_range
+tags:
+  - Erro
+  - Erros
+  - JavaScript
+  - RangeError
+translation_of: Web/JavaScript/Reference/Errors/Precision_range
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<p>A exceção JavaScript "precision is out of range" (precisão fora de alcance) ocorre quando um número que está fora do intervalo que vai de 0 à 20 (ou 21) foi passado para <code>toFixed</code> ou <code>toPrecision</code>.</p>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">RangeError: The number of fractional digits is out of range (Edge)
+RangeError: The precision is out of range (Edge)
+RangeError: precision {0} out of range (Firefox)
+RangeError: toExponential() argument must be between 0 and 20 (Chrome)
+RangeError: toFixed() digits argument must be between 0 and 20 (Chrome)
+RangeError: toPrecision() argument must be between 1 and 21 (Chrome)
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("RangeError")}}</p>
+
+<h2 id="O_que_houve_de_errado">O que houve de errado?</h2>
+
+<p>Existe um argumento de precisão fora do intervalo em um desses métodos:</p>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toExponential()")}}</li>
+ <li>{{jsxref("Number.prototype.toFixed()")}}</li>
+ <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
+</ul>
+
+<p>Po padrão, o intervalo permitido para os métodos acima é de 0 à 20 (ou 21). Todavia, a especificação ECMAScript nos permite extender o intervalo.</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Método</th>
+   <th scope="col">Firefox (SpiderMonkey)</th>
+   <th scope="col">Chrome, Opera (V8)</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{jsxref("Number.prototype.toExponential()")}}</td>
+   <td>0 to 100</td>
+   <td>0 to 20</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Number.prototype.toFixed()")}}</td>
+   <td>-20 to 100</td>
+   <td>0 to 20</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Number.prototype.toPrecision()")}}</td>
+   <td>1 to 100</td>
+   <td>1 to 21</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Casos_inválidos">Casos inválidos</h3>
+
+<pre class="brush: js example-bad">77.1234.toExponential(-1);  // RangeError
+77.1234.toExponential(101); // RangeError
+
+2.34.toFixed(-100);         // RangeError
+2.34.toFixed(1001);         // RangeError
+
+1234.5.toPrecision(-1);     // RangeError
+1234.5.toPrecision(101);    // RangeError
+</pre>
+
+<h3 id="Casos_válidos">Casos válidos</h3>
+
+<pre class="brush: js example-good">77.1234.toExponential(4); // 7.7123e+1
+77.1234.toExponential(2); // 7.71e+1
+
+2.34.toFixed(1); // 2.3
+2.35.toFixed(1); // 2.4 (perceba que ele foi arredondado nesse caso)
+
+5.123456.toPrecision(5); // 5.1235
+5.123456.toPrecision(2); // 5.1
+5.123456.toPrecision(1); // 5
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toExponential()")}}</li>
+ <li>{{jsxref("Number.prototype.toFixed()")}}</li>
+ <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/property_access_denied/index.html b/files/pt-br/web/javascript/reference/errors/property_access_denied/index.html
new file mode 100644
index 0000000000..01bcf0009b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/property_access_denied/index.html
@@ -0,0 +1,42 @@
+---
+title: 'Error: Permission denied to access property "x"'
+slug: Web/JavaScript/Reference/Errors/Property_access_denied
+translation_of: Web/JavaScript/Reference/Errors/Property_access_denied
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">Error: Permission denied to access property "x"
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("Error")}}.</p>
+
+<h2 id="O_que_houve_de_errado">O que houve de errado?</h2>
+
+<p><span class="seoSummary">Tentativa de acessar um objeto no qual você não possui permissões. Provavelmente um {{HTMLElement("iframe")}} carregado de um dominio diferente no qual foi violado o <a href="/en-US/docs/Web/Security/Same-origin_policy">same-origin policy</a>.</span></p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: html">&lt;!DOCTYPE html&gt;
+&lt;html&gt;
+  &lt;head&gt;
+    &lt;iframe id="myframe" src="http://www1.w3c-test.org/common/blank.html"&gt;&lt;/iframe&gt;
+    &lt;script&gt;
+      onload = function() {
+        console.log(frames[0].document);
+        // Error: Permission denied to access property "document"
+      }
+    &lt;/script&gt;
+  &lt;/head&gt;
+  &lt;body&gt;&lt;/body&gt;
+&lt;/html&gt;</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{HTMLElement("iframe")}}</li>
+ <li><a href="/en-US/docs/Web/Security/Same-origin_policy">Same-origin policy</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/read-only/index.html b/files/pt-br/web/javascript/reference/errors/read-only/index.html
new file mode 100644
index 0000000000..fa7770fbcf
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/read-only/index.html
@@ -0,0 +1,81 @@
+---
+title: 'TypeError: "x" is read-only'
+slug: Web/JavaScript/Reference/Errors/Read-only
+tags:
+  - Erros
+  - JavaScript
+  - TypeError
+translation_of: Web/JavaScript/Reference/Errors/Read-only
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">TypeError: "x" is read-only (Firefox)
+TypeError: 0 is read-only (Firefox)
+TypeError: Cannot assign to read only property 'x' of #&lt;Object&gt; (Chrome)
+TypeError: Cannot assign to read only property '0' of [object Array] (Chrome)
+</pre>
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>{{jsxref("TypeError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>A variável global ou propriedade do objeto foi definida como propriedade somente-leitura. (Tecnicamente, esse é um dado de <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty#Writable_attribute">não-escrita</a>.)</p>
+
+<p>Esse erro ocorre apenas em código no <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>. No modo não strict mode, essa atribuição é ignorada silenciosamente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Casos_inválidos">Casos inválidos</h3>
+
+<p>Propriedades somente-leitura não são super comuns, mas elas podem ser criadas utilizando {{jsxref("Object.defineProperty()")}} ou {{jsxref("Object.freeze()")}}.</p>
+
+<pre class="brush: js example-bad">'use strict';
+var obj = Object.freeze({nome: 'Elsa', pontuacao: 157});
+obj.pontuacao = 0;  // TypeError
+
+'use strict';
+Object.defineProperty(this, 'CONTADOR_PULMAO', {value: 2, writable: false});
+CONTADOR_PULMAO = 3;  // TypeError
+
+'use strict';
+var frozenArray = Object.freeze([0, 1, 2]);
+frozenArray[0]++;  // TypeError
+</pre>
+
+<p>Existem também algumas propriedades somente-leitura nativas do Javascript. Talvez você já tentou redefinir um constante matemática.</p>
+
+<pre class="brush: js example-bad">'use strict';
+Math.PI = 4;  // TypeError
+</pre>
+
+<p>Desculpe, você não pode fazer isso.</p>
+
+<p>A variável global <code>undefined</code> também é somente-leitura, então você não pode silenciar o infame erro "undefined is not a function" fazendo isso:</p>
+
+<pre class="brush: js example-bad">'use strict';
+undefined = function() {};  // TypeError: "undefined" is read-only
+</pre>
+
+<h3 id="Casos_válidos">Casos válidos</h3>
+
+<pre class="brush: js example-good">'use strict';
+var obj = Object.freeze({nome: 'Score', pontos: 157});
+obj = {nome: obj.nome, pontos: 0};   // substituindo com o novo objeto funciona
+
+'use strict';
+var CONTADOR_PULMAO = 2;  // uma `var` funciona, porque ela não é somente-leitura
+CONTADOR_PULMAO = 3;  // ok (anatomicamente improvável, porém...)
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li><a href="https://www.answers.com/Q/Which_animals_have_three_lungs">"Quais animais tem três pulmões?" no answers.com</a></li>
+ <li><a href="https://aliens.wikia.com/wiki/Klingon">Klingons</a> (uma outra resposta para essa pergunta)</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/redeclared_parameter/index.html b/files/pt-br/web/javascript/reference/errors/redeclared_parameter/index.html
new file mode 100644
index 0000000000..901557d13b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/redeclared_parameter/index.html
@@ -0,0 +1,60 @@
+---
+title: 'SyntaxError: redeclaration of formal parameter "x"'
+slug: Web/JavaScript/Reference/Errors/Redeclared_parameter
+tags:
+  - Erros
+translation_of: Web/JavaScript/Reference/Errors/Redeclared_parameter
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">SyntaxError: Let/Const redeclaration (Edge)
+SyntaxError: redeclaration of formal parameter "x" (Firefox)
+SyntaxError: Identifier "x" has already been declared (Chrome)
+</pre>
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>O mesmo nome de variável ocorre como parâmetro da função e é então redeclarada atribuindo <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code> no corpo da função. Redeclarando a mesma variável dentro da mesma função ou no escopo do bloco usando <code>let</code> não é permitido em JavaScript.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Neste caso, a variável "arg" redeclara o argumento.</p>
+
+<pre class="brush: js example-bad">function f(arg) {
+  let arg = 'foo';
+}
+
+// SyntaxError: redeclaration of formal parameter "arg"
+</pre>
+
+<p>Se você quiser mudar o valor de "arg" no corpo da função, você pode fazer, mas você não precisa declarar novamente a mesma variável. Em outras palavras: você pode omitir a palavra chave <code>let</code>. Se você quiser criar uma nova variável, você precisa renomea-la, pois isso conflita com o parâmetro da função.</p>
+
+<pre class="brush: js example-good">function f(arg) {
+  arg = 'foo';
+}
+
+function f(arg) {
+  let bar = 'foo';
+}
+</pre>
+
+<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
+
+<ul>
+ <li>Antes do Firefox 49 {{geckoRelease(49)}}, isto foi lançado como um {{jsxref("TypeError")}} ({{bug(1275240)}}).</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const">const</a></code></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Grammar_and_Types#Declarations">Declaring variables</a> in the <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/stmt_after_return/index.html b/files/pt-br/web/javascript/reference/errors/stmt_after_return/index.html
new file mode 100644
index 0000000000..6c2ad3146a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/stmt_after_return/index.html
@@ -0,0 +1,74 @@
+---
+title: 'Warning: unreachable code after return statement'
+slug: Web/JavaScript/Reference/Errors/Stmt_after_return
+translation_of: Web/JavaScript/Reference/Errors/Stmt_after_return
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">Warning: unreachable code after return statement (Firefox)
+</pre>
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>Warning</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Codigo inacessível depois da declaração de retorno pode ocorrer nas seguintes situações:</p>
+
+<ul>
+ <li>Quando usado em uma expressão após a declaração de um {{jsxref("Statements/return", "return")}} , ou</li>
+ <li>quando usado em uma expressão <strong>return</strong> sem ponto e vírgula porém incluindo uma expressão diretamente depois.</li>
+</ul>
+
+<p>Quando existe uma expressão após uma declaração válida de <code>return, </code>um warning é dado para indicar que o código depois da declaração <code>return</code> é inacessível, significando que ele pode nunca ser executado.</p>
+
+<p>Porque eu devo usar ponto-e-virgula após declarações <code>return</code>? No caso de declarações <code>return</code> sem ponto-e-vírgula, ele pode deixar obscuro se o desenvolvedor quis usar o return na proxima linha, ou parar a execução e retornar. O warning indica que há uma ambiguidade no modo que a declaração <code>return</code> foi escrita.</p>
+
+<p>Warnings não serão mostrado para declarações return sem ponto-e-vírgula nas seguintes situações:</p>
+
+<ul>
+ <li>{{jsxref("Statements/throw", "throw")}}</li>
+ <li>{{jsxref("Statements/break", "break")}}</li>
+ <li>{{jsxref("Statements/var", "var")}}</li>
+ <li>{{jsxref("Statements/function", "function")}}</li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Casos_Inválidos">Casos Inválidos</h3>
+
+<pre class="brush: js example-bad">function f() {
+  var x = 3;
+  x += 4;
+  return x;   // return exits the function immediately
+  x -= 3;     // so this line will never run; it is unreachable
+}
+
+function f() {
+  return     // this is treated like `return;`
+    3 + 4;   // so the function returns, and this line is never reached
+}
+</pre>
+
+<h3 id="Casos_Válidos">Casos Válidos</h3>
+
+<pre class="brush: js example-good">function f() {
+  var x = 3;
+  x += 4;
+  x -= 3;
+  return x;  // OK: return after all other statements
+}
+
+function f() {
+  return 3 + 4  // OK: semicolon-less return with expression on the same line
+}
+</pre>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/return", "Automatic Semicolon Insertion", "#Automatic_Semicolon_Insertion", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/too_much_recursion/index.html b/files/pt-br/web/javascript/reference/errors/too_much_recursion/index.html
new file mode 100644
index 0000000000..26637da662
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/too_much_recursion/index.html
@@ -0,0 +1,66 @@
+---
+title: 'InternalError: too much recursion'
+slug: Web/JavaScript/Reference/Errors/Too_much_recursion
+translation_of: Web/JavaScript/Reference/Errors/Too_much_recursion
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">Error: Out of stack space (Edge)
+InternalError: too much recursion (Firefox)
+RangeError: Maximum call stack size exceeded (Chrome)
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("InternalError")}}.</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Uma função que invoca a si mesma é chamada <em>função recursiva</em>. Assim que uma condição é atendida, a função para de se invocar. </p>
+
+<p>De certa forma, recursão é análoga a um loop. Ambos executam o mesmo código múltiplas vezes, e ambos exigem uma condição (para evitar um loop infinito ou, nesse caso, uma recursão infinita). <span class="seoSummary">Quando são feitas excessivas invocações, ou a função não possui uma condição para interromper a recursividade, este erro é lançado.</span></p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Esta função recursiva roda 10 vezes, como definido pela condição de saída.</p>
+
+<pre class="brush: js">function loop(x) {
+  if (x &gt;= 10) // "x &gt;= 10" é a condição de saída
+    return;
+
+  loop(x + 1); // o código recursivo em si
+}
+loop(0);</pre>
+
+<p>Mudar esta condição para um valor extremamente alto não vai funcionar:</p>
+
+<pre class="brush: js example-bad">function loop(x) {
+  if (x &gt;= 1000000000000)
+    return;
+
+  loop(x + 1);
+}
+loop(0);
+
+// InternalError: too much recursion</pre>
+
+<p>A seguinte função recursiva não possui condição de saída. Assim, ela vai continuar se invocando indefinidamente (até que o erro seja lançado e a execução interrom).</p>
+
+<pre class="brush: js example-bad">function loop(x) {
+ // Não há condição de saída
+
+loop(x + 1); // Código recursivo
+}
+
+loop(0);
+
+// InternalError: too much recursion</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{Glossary("Recursion")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Functions#Recursion">Funções recursivas</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/undeclared_var/index.html b/files/pt-br/web/javascript/reference/errors/undeclared_var/index.html
new file mode 100644
index 0000000000..a51d080828
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/undeclared_var/index.html
@@ -0,0 +1,62 @@
+---
+title: 'ReferenceError: Atribuição à variável não declarada "x"'
+slug: Web/JavaScript/Reference/Errors/Undeclared_var
+translation_of: Web/JavaScript/Reference/Errors/Undeclared_var
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Message">Message</h2>
+
+<pre class="syntaxbox">ReferenceError: Atribuição à variável não declarada "x"(Firefox)
+ReferenceError: "x" não está definido (Chrome)
+ReferenceError: Variável indefinida em <em>strict mode</em> (Edge)
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("ReferenceError")}} aviso em <em><a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a></em> somente.</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Um valor foi atribuído a uma variável não declarada. Em outras palavras, houve uma atribuição sem a palavra-chave var. Existem algumas diferenças entre as variáveis declaradas e não declaradas, o que pode levar a resultados inesperados e é por isso que o JavaScript apresenta um erro no modo estrito.</p>
+
+<p>Três coisas a observar sobre as variáveis declaradas e não declaradas:</p>
+
+<ul>
+ <li>Variáveis declaradas são limitadas no contexto de execução em que são declarados. Variáveis não declaradas são sempre globais.</li>
+ <li>Variáveis declaradas são criados antes de qualquer código ser executado. Variáveis não declaradas não existem até que o código atribuido for executado.</li>
+ <li>Variáveis declaradas são uma propriedade não-configurável de seu contexto de execução (função ou global). Variáveis não declaradas são configuráveis (por exemplo, pode ser excluído).</li>
+</ul>
+
+<p>Para mais exemplos, veja a página de referência <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a></code>.</p>
+
+<p>Erros sobre atribuições de variáveis não declaradas ocorrem apenas em <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">código de modo estrito</a>. Em código não-estrito, eles são silenciosamente ignorados.</p>
+
+<h2 id="Examplos">Examplos</h2>
+
+<h3 id="Casos_inválidos">Casos inválidos</h3>
+
+<p>neste caso, a variavel "bar" é uma variavel não declarada.</p>
+
+<pre class="brush: js example-bad">function foo() {
+  "use strict";
+  bar = true;
+}
+foo(); // ReferenceError: assignment to undeclared variable bar
+</pre>
+
+<h3 id="Casos_válidos">Casos válidos</h3>
+
+<p>Para fazer uma variável declarada "bar", você pode adicionar a palavra-chave <a href="/en-US/docs/Web/JavaScript/Reference/Statements/var">var</a> na frente dele.</p>
+
+<pre class="brush: js example-good">function foo() {
+  "use strict";
+  var bar = true;
+}
+foo();</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><em><a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">Strict mode</a></em></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/undefined_prop/index.html b/files/pt-br/web/javascript/reference/errors/undefined_prop/index.html
new file mode 100644
index 0000000000..a15985670b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/undefined_prop/index.html
@@ -0,0 +1,67 @@
+---
+title: 'ReferenceError: reference to undefined property "x"'
+slug: Web/JavaScript/Reference/Errors/Undefined_prop
+tags:
+  - Erros
+  - JavaScript
+  - Modo Restrito
+  - ReferenceError
+translation_of: Web/JavaScript/Reference/Errors/Undefined_prop
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">ReferenceError: reference to undefined property "x" (Firefox)
+</pre>
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>(Apenas no Firefox) O aviso {{jsxref("ReferenceError")}} é reportado somente se a preferência <code>javascript.options.strict</code> está definida como <code>true</code>.</p>
+
+<h2 id="O_que_está_errado">O que está errado?</h2>
+
+<div class="oSioSc">
+<div id="tw-target">
+<div class="g9WsWb" id="kAz1tf">
+<div class="tw-ta-container tw-nfl" id="tw-target-text-container">
+<p class="tw-data-text tw-text-large tw-ta" dir="ltr" id="tw-target-text" style="text-align: left;"><span lang="pt">O script tentou acessar uma propriedade de objeto que não existe. Existem duas maneiras de acessar propriedades; veja a página de referência {{jsxref ("Operators / Property_Accessors", "property accessors", 0, 1)}} para saber mais sobre eles.</span></p>
+</div>
+</div>
+</div>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Errado">Errado</h3>
+
+<p>Neste caso, a propriedade <code>bar</code> é uma propriedade não definida, assim, ocorrerá um <code>ReferenceError</code>.</p>
+
+<pre class="brush: js example-bad">var foo = {};
+foo.bar; // ReferenceError: reference to undefined property "bar"
+</pre>
+
+<h3 id="Certo">Certo</h3>
+
+<div class="tw-ta-container tw-nfl" id="tw-target-text-container">
+<p class="tw-data-text tw-text-large tw-ta" dir="ltr" id="tw-target-text" style="text-align: left;"><span lang="pt">Para evitar o erro, você precisa adicionar uma definição de <code>bar</code> ao objeto ou verificar a existência da propriedade <code>bar</code> antes de tentar acessá-la; Uma maneira de fazer isso é usar o método {{jsxref ("Object.prototype.hasOwnProperty ()")}}, desta forma:</span></p>
+</div>
+
+<pre class="brush: js example-good">var foo = {};
+
+// Define a propriedade bar
+
+foo.bar = 'moon';
+console.log(foo.bar); // "moon"
+
+// Teste para ter certeza se bar existe antes de acessa-lo
+
+if (foo.hasOwnProperty('bar')) {
+  console.log(foo.bar);
+}</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Operators/Property_Accessors", "property accessors", 0, 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/unexpected_token/index.html b/files/pt-br/web/javascript/reference/errors/unexpected_token/index.html
new file mode 100644
index 0000000000..7455321080
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/unexpected_token/index.html
@@ -0,0 +1,51 @@
+---
+title: 'SyntaxError: Unexpected token'
+slug: Web/JavaScript/Reference/Errors/Unexpected_token
+tags:
+  - Erro de Sintaxe
+  - Erros
+  - JavaScript
+  - SyntaxError
+translation_of: Web/JavaScript/Reference/Errors/Unexpected_token
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">SyntaxError: expected expression, got "x"
+SyntaxError: expected property name, got "x"
+SyntaxError: expected target, got "x"
+SyntaxError: expected rest argument name, got "x"
+SyntaxError: expected closing parenthesis, got "x"
+SyntaxError: expected '=&gt;' after argument list, got "x"
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Uma construção específica da linguagem era esperada, mas algo não foi fornecido. Isto deve ser um simples erro de digitação.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Expressão_esperada">Expressão esperada</h3>
+
+<p>Por exemplo, quando funções são chamadas, vírgulas sem um valor na sequência não são permitidas. O JavaScript esperarará outro argumento, como pode ser qualquer expressão.</p>
+
+<pre class="brush: js example-bad">Math.max(2, 42,);
+// SyntaxError: expected expression, got ')'
+</pre>
+
+<p>O correto é omitir a vírgula ou adicionar outro argumento:</p>
+
+<pre class="brush: js example-good">Math.max(2, 42);
+Math.max(2, 42, 13 + 37);
+</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.max()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/unexpected_type/index.html b/files/pt-br/web/javascript/reference/errors/unexpected_type/index.html
new file mode 100644
index 0000000000..8e05992723
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/unexpected_type/index.html
@@ -0,0 +1,67 @@
+---
+title: 'TypeError: "x" is (not) "y"'
+slug: Web/JavaScript/Reference/Errors/Unexpected_type
+tags:
+  - Erros
+  - JavaScript
+  - TypeError
+translation_of: Web/JavaScript/Reference/Errors/Unexpected_type
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">Tipo do erro: "x" é (não é) "y"
+
+Exemplos:
+Tipo do erro: "x" é indefinido
+Tipo do erro: "x" é nulo
+Tipo do erro: "x" indefinido" não é um objeto
+Tipo do erro: "x" não é um objeto ou é nulo
+Tipo do erro: "x" não é um símbolo
+</pre>
+
+<h2 id="Tipo_de_erro">Tipo de erro</h2>
+
+<p>{{jsxref("TypeError")}}.</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Houve um tipo inesperado. Isso ocorre muitas vezes com valores {{jsxref("undefined")}} ou {{jsxref("null")}}.</p>
+
+<p>Além disso, certos métodos, tais como {{jsxref("Object.create()")}} ou {{jsxref("Symbol.keyFor()")}}, requerem um tipo específico, que deve ser fornecido.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Casos_inválidos">Casos inválidos</h3>
+
+<pre class="brush: js example-bad">// casos undefined e null nos quais o método substring não vai funcionar
+var foo = undefined;
+foo.substring(1); // TypeError: foo is undefined
+
+var foo = null;
+foo.substring(1); // TypeError: foo is null
+
+
+// Certos métodos podem precisar de um tipo específico
+var foo = {}
+Symbol.keyFor(foo); // TypeError: foo is not a symbol
+
+var foo = 'bar'
+Object.create(foo); // TypeError: "foo" is not an object or null
+</pre>
+
+<h3 id="Consertando_o_problema">Consertando o problema</h3>
+
+<p>Para consertar o pointeiro nulo para valores <code>undefined</code> ou <code>null</code>,  você pode utilizar o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof">typeof</a> , por exemplo.</p>
+
+<pre class="brush: js">if (typeof foo !== 'undefined') {
+  // Agora nós sabemos que foo está definido, então podemos prosseguir.
+}</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("undefined")}}</li>
+ <li>{{jsxref("null")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/errors/unterminated_string_literal/index.html b/files/pt-br/web/javascript/reference/errors/unterminated_string_literal/index.html
new file mode 100644
index 0000000000..831d9842e2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/errors/unterminated_string_literal/index.html
@@ -0,0 +1,63 @@
+---
+title: 'SyntaxError: unterminated string literal'
+slug: Web/JavaScript/Reference/Errors/Unterminated_string_literal
+translation_of: Web/JavaScript/Reference/Errors/Unterminated_string_literal
+---
+<div>{{jsSidebar("Errors")}}</div>
+
+<h2 id="Mensagem">Mensagem</h2>
+
+<pre class="syntaxbox">SyntaxError: unterminated string literal
+</pre>
+
+<h2 id="Tipo_de_Erro">Tipo de Erro</h2>
+
+<p>{{jsxref("SyntaxError")}}</p>
+
+<h2 id="O_que_deu_errado">O que deu errado?</h2>
+
+<p>Há uma {{jsxref("String")}} não finalizada em algum lugar do código. String literais devem se fechadas com aspas simples (<code>'</code>) ou duplas (<code>"</code>) . O JavaScript não faz distinção entre strings com aspas simples ou aspas duplas. <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#Escape_notation">As sequências de escape </a>trabalham com strings criadas tanto com aspas simples, quanto com aspas duplas. Para consertar este erro, verifique se:</p>
+
+<ul>
+ <li>você abriu e fechou sua string literal com aspas (simples ou duplas),</li>
+ <li>você escapou sua string literal corretamente,</li>
+ <li>sua string funciona corretamente em várias linhas, se houver.</li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Múltiplas_linhas">Múltiplas linhas</h3>
+
+<p>Você não pode dividir sua string em múltiplas linhas em Javascript:</p>
+
+<pre class="brush: js example-bad">var longString = "This is a very long string which needs
+                  to wrap across multiple lines because
+                  otherwise my code is unreadable.";
+// SyntaxError: unterminated string literal</pre>
+
+<p>Ao invés disso, você deve utilizar o operador<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition"> + operator</a>, uma barra invertida(\), ou <a href="/en-US/docs/Web/JavaScript/Reference/Template_literals">modelos literais</a>. Uma forma de uso do operador<code> +, seria assim:</code></p>
+
+<pre class="brush: js example-good">var longString = "This is a very long string which needs " +
+                 "to wrap across multiple lines because " +
+                 "otherwise my code is unreadable.";
+</pre>
+
+<p>Ou você pode usar uma barra invertida ("\") ao final de cada linha para indicar que a string continuará na próxima linha. Certifique-se de que não há espaço ou qualquer outro caractere após a barra invertida (excento quando for uma quebra de linha), ou como indentação; caso contrário, não funcionará. Esta forma ficaria assim:</p>
+
+<pre class="brush: js example-good">var longString = "This is a very long string which needs \
+to wrap across multiple lines because \
+otherwise my code is unreadable.";
+</pre>
+
+<p>Uma outra possibilidade é usar um  <a href="/en-US/docs/Web/JavaScript/Reference/Template_literals">modelo literal</a>, que é suportado pelos ambientes ECMAScript 2015:</p>
+
+<pre class="brush: js example-good">var longString = `This is a very long string which needs
+                  to wrap across multiple lines because
+                  otherwise my code is unreadable.`;</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Template_literals">Modelos literais</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/functions/arguments/index.html b/files/pt-br/web/javascript/reference/functions/arguments/index.html
new file mode 100644
index 0000000000..5b08e6c5ba
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/functions/arguments/index.html
@@ -0,0 +1,258 @@
+---
+title: Arguments object
+slug: Web/JavaScript/Reference/Functions/arguments
+tags:
+  - Funções
+  - JavaScript
+  - Referência(2)
+  - argumentos
+translation_of: Web/JavaScript/Reference/Functions/arguments
+---
+<div>
+<div>{{jsSidebar("Functions")}}</div>
+</div>
+
+<p>O objeto <strong><code>arguments</code></strong> é como um objeto Array correspondendo aos argumentos passados para uma função.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">arguments</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O objeto <code>arguments</code> é uma variável local disponível dentro de todas as funções. Você pode referenciar os argumentos de uma função dentro da função usando o objeto <code>arguments</code>. Esse objeto contém um registro para cada argumento fornecido para a função, com o índice do primeiro registro começando em 0. Por exemplo, se são passados três argumentos para uma função, você pode referenciá-los como a seguir: </p>
+
+<pre class="brush: js">arguments[0]
+arguments[1]
+arguments[2]
+</pre>
+
+<p>Os argumentos também podem ser definidos:</p>
+
+<pre class="brush: js">arguments[1] = 'novo valor';</pre>
+
+<p>O objeto <code>argumentos</code> não é um {{jsxref("Array")}}. É similar a um Array, mas não possui as propriedades de <code>Array</code>, exceto <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/length" title="JavaScript/Reference/Functions_and_function_scope/arguments/length">length</a></code>. Por exemplo, ele não possui o método <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop" title="JavaScript/Reference/Global_Objects/Array/pop">pop</a></code>. Entretanto, ele pode ser convertido em um <code>Array</code> real:</p>
+
+<pre class="brush: java"><code>var args = Array.prototype.slice.call(arguments);
+var args = [].slice.call(arguments);
+
+// ES2015
+var args = Array.from(arguments);</code></pre>
+
+<div class="warning">
+<p>Usar slice nos argumentos impedem otimizações em alguns motores JavaScript (V8 por exemplo - <a href="https://github.com/petkaantonov/bluebird/wiki/Optimization-killers#3-managing-arguments">mais informações</a>). Se você precisar, tente construir um novo array iterando através dos argumentos do objeto. Uma alternativa seria usar o construtor do <code>Array</code> como uma função:</p>
+
+<pre class="brush: js"><code>var args = (arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments));</code></pre>
+</div>
+
+<p>Você pode usar o objeto <code>arguments</code> se você chamar uma função com mais argumentos do que ele é formalmente declarado para aceitar. Esta técnica é útil para funções que podem ser passada em um número de variáveis de argumentos. Você pode usar <code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/length" title="JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code> para determinar o número de argumentos passado para a função, e então processar cada argumento usando o objeto <code>arguments</code>. Para determinar o número de parâmetros declarados na <a href="/pt-BR/docs/Glossary/Signature/Function">assinatura</a> da função, use a propriedade<code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function/length" title="JavaScript/Reference/Global_Objects/Function/length"> Function.length</a></code>.</p>
+
+<h3 id="Usando_typeof_com_Arguments">Usando typeof com Arguments</h3>
+
+<p>O comando <code>typeof arguments</code> retorna 'object'. </p>
+
+<pre class="brush: js"><code>console.log(typeof arguments); // 'object'</code></pre>
+
+<p>O <code>typeof</code> de argumentos individuais pode ser determinado com o uso do índice.</p>
+
+<pre class="brush: js"><code>console.log(typeof arguments[0]); //this will return the typeof individual arguments.</code></pre>
+
+<h3 id="Usando_a_Sintaxe_Spread_com_Arguments">Usando a Sintaxe Spread com Arguments</h3>
+
+<p>Você também pode usar o método {{jsxref("Array.from()")}} ou o <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Spread_operator">operador spread</a> para converter argumentos em um Array real:</p>
+
+<pre class="brush: js"><code>var args = Array.from(arguments);
+var args = [...arguments];</code></pre>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee" title="JavaScript/Reference/Functions_and_function_scope/arguments/callee">arguments.callee</a></code></dt>
+ <dd>Referência para a função atualmente em execução.</dd>
+ <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/caller" title="JavaScript/Reference/Functions_and_function_scope/arguments/caller">arguments.caller</a></code> {{ Obsolete_inline() }}</dt>
+ <dd>Referência para a função que invocou a função atualmente em execução.</dd>
+ <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/length" title="JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code></dt>
+ <dd>Referência para o número de argumentos passados para a função.</dd>
+ <dt><code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments/@@iterator" title="JavaScript/Reference/Functions_and_function_scope/arguments/@@iterator">arguments[@@iterator]</a></code></dt>
+ <dd>Retorna um novo objeto Array Iterator que contém os valores para cada índice dos argumentos.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Definindo_uma_função_que_concatena_várias_strings">Definindo uma função que concatena várias strings</h3>
+
+<p>Este exemplo define uma função que <span id="result_box" lang="pt"><span class="hps">concatena</span> </span>várias strings. O único argumento formal para a função é uma string que especifica os caracteres que separam os itens a concatenar. A função é definida como se segue:</p>
+
+<pre class="brush:js">function myConcat(separator) {
+  var args = Array.prototype.slice.call(arguments, 1);
+  return args.join(separator);
+}</pre>
+
+<p>Você pode passar qualquer número de argumentos para essa função e ela cria uma lista usando cada argumento como um item na lista.</p>
+
+<pre class="brush:js">// returns "red, orange, blue"
+myConcat(", ", "red", "orange", "blue");
+
+// returns "elephant; giraffe; lion; cheetah"
+myConcat("; ", "elephant", "giraffe", "lion", "cheetah");
+
+// returns "sage. basil. oregano. pepper. parsley"
+myConcat(". ", "sage", "basil", "oregano", "pepper", "parsley");</pre>
+
+<h3 id="Definindo_uma_função_que_cria_listas_HTML">Definindo uma função que cria listas HTML</h3>
+
+<p>Este exemplo define uma função que cria uma string contatenado HTML para uma lista. O único argumento formal para a função é uma string que é "u" se a lista for <span class="short_text" id="result_box" lang="pt"><span class="hps">desordenada</span></span> (<span class="short_text" id="result_box" lang="pt"><span class="hps">marcadores</span></span>), ou "o" se a lista for ordenada (<span class="short_text" id="result_box" lang="pt"><span class="hps">numerada</span></span>). A função é definida como se segue:</p>
+
+<pre class="brush:js">function list(type) {
+  var result = "&lt;" + type + "l&gt;&lt;li&gt;";
+  var args = Array.prototype.slice.call(arguments, 1);
+  result += args.join("&lt;/li&gt;&lt;li&gt;");
+  result += "&lt;/li&gt;&lt;/" + type + "l&gt;"; // end list
+
+  return result;
+}</pre>
+
+<p>Você pode passar qualquer número de argumentos para essa função, e ela adiciona cada argumento como um item para uma lista do tipo indicado. Por exemplo:</p>
+
+<pre class="brush:js">var listHTML = list("u", "One", "Two", "Three");
+
+/* listHTML is:
+
+"&lt;ul&gt;&lt;li&gt;One&lt;/li&gt;&lt;li&gt;Two&lt;/li&gt;&lt;li&gt;Three&lt;/li&gt;&lt;/ul&gt;"
+
+*/</pre>
+
+<h3 id="Rest_default_e_parâmetros_desestruturados">Rest, default e parâmetros desestruturados</h3>
+
+<p>O objeto <code>arguments</code> pode ser usado em conjunto com os parâmetros <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a> e <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destruturados</a>.</p>
+
+<pre class="brush: js"><code>function foo(...args) {
+  return args;
+}
+foo(1, 2, 3); // [1,2,3]</code></pre>
+
+<p>Enquanto a presença dos parâmetros <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, ou <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">desestruturados</a> não alteram o <a href="/pt-BR/docs/Web/JavaScript/Reference/Strict_mode#Making_eval_and_arguments_simpler">comportamento do objeto <code>arguments</code> no código em strict mode</a>, existe uma sutil diferença para o código non-strict.</p>
+
+<p>Quando uma função não-strict <strong><strong>não</strong></strong> contém parâmetros <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, ou <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">desestruturados</a>, os valores no objeto <code>arguments</code> <strong>modificam</strong> os valores dos argumentos (e vice-versa). Veja o código:</p>
+
+<pre class="brush: js"><code>function func(a) {
+  arguments[0] = 99; // updating arguments[0] also updates a
+  console.log(a);
+}
+func(10); // 99</code></pre>
+
+<p>e</p>
+
+<pre class="brush: js"><code>function func(a) {
+  a = 99; // updating a also updates arguments[0]
+  console.log(arguments[0]);
+}
+func(10); // 99</code></pre>
+
+<p>Quando uma função não-strict <strong>contém</strong> parâmetros <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest</a>, <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/Default_parameters">default</a>, ou <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">desestruturados</a>, os valores no objeto <code>arguments</code> <strong>não modificam</strong> os valores dos argumentos (e vice-versa). Ao invés disso, eles refletem os argumentos fornecidos no momento da chamada:</p>
+
+<pre class="brush: js"><code>function func(a = 55) {
+  arguments[0] = 99; // updating arguments[0] does not also update a
+  console.log(a);
+}
+func(10); // 10</code></pre>
+
+<p>e</p>
+
+<pre class="brush: js"><code>function func(a = 55) {
+  a = 99; // updating a does not also update arguments[0]
+  console.log(arguments[0]);
+}
+func(10); // 10</code></pre>
+
+<p>e</p>
+
+<pre class="brush: js"><code>function func(a = 55) {
+  console.log(arguments[0]);
+}
+func(); // undefined</code></pre>
+
+<h2 id="Especificações"><span class="short_text" id="result_box" lang="pt"><span class="hps">Especificações</span></span></h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col"><span class="short_text" id="result_box" lang="pt"><span class="hps">Especificações</span></span></th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td><span class="short_text" id="result_box" lang="pt"><span class="hps">Definição</span> <span class="hps">inicial.</span> <span class="hps">Implementado em</span> <span class="hps">JavaScript 1.1</span></span></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-10.6', 'Arguments Object')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-arguments-exotic-objects', 'Arguments Exotic Objects')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/functions/arrow_functions/index.html b/files/pt-br/web/javascript/reference/functions/arrow_functions/index.html
new file mode 100644
index 0000000000..1694545a71
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/functions/arrow_functions/index.html
@@ -0,0 +1,384 @@
+---
+title: Arrow functions
+slug: Web/JavaScript/Reference/Functions/Arrow_functions
+tags:
+  - ECMAScript 2015
+  - Funções
+  - Intermediário
+  - JavaScript
+  - Referencia
+translation_of: Web/JavaScript/Reference/Functions/Arrow_functions
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>Uma <strong>expressão <em>arrow function</em></strong> possui uma sintaxe mais curta quando comparada a uma expressão de função (<em><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/function">function expression</a></em>) e não tem seu próprio <em><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/this">this</a></em>, <em><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></em>, <em><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/super">super</a></em> ou <em><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a></em>. Estas expressões de funções são melhor aplicadas para funções que não sejam métodos, e elas não podem ser usadas como construtoras (<em>constructors</em>).</p>
+
+<p>{{EmbedInteractiveExample("pages/js/functions-arrow.html")}}</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<h3 id="Sintaxe_básica">Sintaxe básica</h3>
+
+<pre>(param1, param2, …, paramN) =&gt; { statements }
+(param1, param2, …, paramN) =&gt; expression
+// equivalente a: =&gt; { return expression; }
+
+// Parênteses são opcionais quando só há um nome de parâmetro:
+(singleParam) =&gt; { statements }
+singleParam =&gt; { statements }
+
+// A lista de parâmetros para uma função sem parâmetros deve ser escrita com um par de parênteses.
+() =&gt; { statements }</pre>
+
+<h3 id="Sintaxe_avançada">Sintaxe avançada</h3>
+
+<pre>// Envolva o corpo da função em parênteses para retornar uma expressão literal de objeto:
+params =&gt; ({foo: bar})
+
+// Parâmetros rest (<em><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameters</a>)</em> e parâmetros padrões (<em><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/Default_parameters">default parameters</a></em>) são suportados
+(param1, param2, ...rest) =&gt; { statements }
+(param1 = defaultValue1, param2, …, paramN = defaultValueN) =&gt; { statements }
+
+// Desestruturação (<em><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destructuring</a></em>) dentro da lista de parâmetros também é suportado
+var f = ([a, b] = [1, 2], {x: c} = {x: a + b}) =&gt; a + b + c;
+f(); // 6</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Veja também <a href="https://hacks.mozilla.org/2015/06/es6-in-depth-arrow-functions/">"ES6 In Depth: Arrow functions" on hacks.mozilla.org</a>.</p>
+
+<p>Dois fatores influenciaram a introdução das <em>arrow functions</em>: funções mais curtas e a inexistência da palavra chave <code>this</code>.</p>
+
+<h3 id="Funções_mais_curtas">Funções mais curtas</h3>
+
+<pre><code>var elements = [
+  'Hydrogen',
+  'Helium',
+  'Lithium',
+  'Beryllium'
+];
+
+elements.map(function(element) {
+  return element.length;
+}); // esta sentença retorna o array: [8, 6, 7, 9]
+
+// A função regular acima pode ser escrita como a <em>arrow function</em> abaixo
+elements.map((element) =&gt; {
+  return element.length;
+}); // [8, 6, 7, 9]
+
+// Quando só existe um parâmetro, podemos remover os parênteses envolvendo os parâmetros:
+elements.map(element =&gt; {
+  return element.length;
+}); // [8, 6, 7, 9]
+
+// Quando a única sentença em uma <em>arrow function</em> é `return`, podemos remover `return` e remover
+// as chaves envolvendo a sentença
+elements.map(element =&gt; element.length); // [8, 6, 7, 9]
+
+// Neste caso, porque só precisamos da propriedade <em>length</em>, podemos usar o parâmetro de destruição (<em>destructing parameter</em>):
+// Note que a <em>string</em> `"<em>length</em>"` corresponde a propriedade que queremos obter enquanto que a
+// obviamente propriedade não especial `<em>lengthFooBArX</em>` é só o nome de uma variável que pode ser mudado
+// para qualquer nome válido de variável que você quiser
+elements.map(({ "length": lengthFooBArX }) =&gt; lengthFooBArX); // [8, 6, 7, 9]
+
+// Esta atribuição de parâmetro de destruição (<em>destructing parameter</em>) pode ser escrita como visto abaixo. Entretanto, note que
+// não há um específico `"length"` para selecionar qual propriedade nós queremos obter. Ao invés disso, o nome literal
+// da própria variável `length` é usado como a propriedade que queremos recuperar do objeto.
+elements.map(({ length }) =&gt; length); // [8, 6, 7, 9]</code></pre>
+
+<h3 id="Sem_this_separado">Sem <code>this</code> separado</h3>
+
+<p>Antes das <em>arrow functions</em>, toda nova função definia seu próprio valor de <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/this">this</a> (baseado em como a função era chamada, um novo objeto no caso de um construtor, <em>undefined</em> em chamadas de funções com modo estrito (<em><a href="/pt-BR/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>)</em>, o objeto base se a função é chamada como um "método de objeto", etc.). Este comportamento é importuno com um estilo de programação orientado a objeto.</p>
+
+<pre class="brush: js">function Person() {
+  // O contrutor Person() define `<code>this`</code> como uma instância dele mesmo.
+  this.age = 0;
+
+  setInterval(function growUp() {
+    // Em modo não estrito, a função growUp() define `this`
+    // como o objeto global (porque é onde growUp() é executado.),
+    // que é diferente ao `this`
+    // definido pelo construtor Person().
+    this.age++;
+  }, 1000);
+}
+
+var p = new Person();</pre>
+
+<p>No ECMAScript 3/5, este comportamento era corrigido definindo o valor em <code>this</code> à uma variável que pudesse ser encapsulada.</p>
+
+<pre class="brush: js">function Person() {
+  var that = this;
+  that.age = 0;
+
+  setInterval(function growUp() {
+    // A chamada a função refere à variáevel `that` da qual
+    // o valor é o objeto esperado.
+    that.age++;
+  }, 1000);
+}</pre>
+
+<p>Alternativamente, uma função de ligação (<a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">bound function</a>) pode ser criada para que o valor pré-atribuido à <code>this</code> seja passado para a função alvo de ligação (a função <code>growUp()</code> no exemplo acima.</p>
+
+<p>Uma <em>arrow function</em> não tem seu próprio <code>this;</code> o valor <code>this</code> do contexto léxico encapsulado é usado. Ex: <em>Arrow functions</em> seguem as regras normais de pesquisa de variáveis. Então, ao procurar por <code>this</code>, que não está no escopo atual elas acabam encontrando <code>this</code> no escopo encapsulado. Assim, no código a seguir, o <code>this</code> dentro da função que é passado para <code>setInterval</code> tem o mesmo valor do <code>this</code> na função lexicamente encapsulada:</p>
+
+<pre class="brush: js">function Person(){
+  this.age = 0;
+
+  setInterval(() =&gt; {
+    this.age++; // |this| corretamente se refere ao objeto Person
+  }, 1000);
+}
+
+var p = new Person();</pre>
+
+<h4 id="Relação_com_strict_mode">Relação com <em>strict mode</em></h4>
+
+<p>Considerando que <code>this</code> vem do contexto léxico envolvente, as regras do modo estrito (<em><a href="/pt-BR/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a></em>) em relação ao <code>this</code> são ignoradas.</p>
+
+<pre class="brush: js">var f = () =&gt; { 'use strict'; return this };
+f() === window; // ou o objeto global</pre>
+
+<p>O restante das regras do modo estrito (<em>strict mode)</em> são aplicadas normalmente.</p>
+
+<h4 id="Invocação_por_call_ou_apply">Invocação por call ou apply</h4>
+
+<p>Já que as <em>arrow functions</em> não têm o próprio  <code>this</code>, os métodos <code>call()</code> ou <code>apply()</code> só podem passar parâmetros. <code>thisArg</code> é ignorado.</p>
+
+<pre><code>var adder = {
+  base: 1,
+
+  add: function(a) {
+    var f = v =&gt; v + this.base;
+    return f(a);
+  },
+
+  addThruCall: function(a) {
+    var f = v =&gt; v + this.base;
+    var b = {
+      base: 2
+    };
+
+    return f.call(b, a);
+  }
+};
+
+console.log(adder.add(1));         // Deve logar 2
+console.log(adder.addThruCall(1)); // Deve logar 2 ainda</code></pre>
+
+<h3 id="Sem_ligação_(binding)_de_argumentos_(arguments)">Sem ligação (<em>binding</em>) de argumentos (<code><em>arguments</em></code>)</h3>
+
+<p><em>Arrow functions</em> não tem o próprio objeto argumentos (<a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/arguments">arguments object</a>). Assim, neste exemplo, <code>arguments</code> é simplesmente uma referência aos argumentos do escopo encapsulado:</p>
+
+<pre><code>var arguments = [1, 2, 3];
+var arr = () =&gt; arguments[0];
+
+arr(); // 1
+
+function foo(n) {
+  var f = () =&gt; arguments[0] + n; // ligação implícita dos argumentos de foo. arguments[0] é n
+  return f();
+}
+
+foo(3); // 6</code></pre>
+
+<p>Na maioria dos casos, usar parâmetros rest (<em><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/rest_parameters">rest parameters</a></em>) é uma boa alternativa a usar um objeto <code>arguments</code>.</p>
+
+<pre class="brush: js"><code>function foo(n) {
+  var f = (...args) =&gt; args[0] + n;
+  return f(10);
+}
+
+foo(1); // 11</code></pre>
+
+<h3 id="Arrow_functions_usadas_como_métodos"><em>Arrow functions</em> usadas como métodos</h3>
+
+<p>Como afirmado anteriormente, expressões <em>arrow function</em> são melhores para funções que não sejam métods. Vamos ver o que acontece quando tentamos usá-las como métodos.</p>
+
+<pre><code>'use strict';
+
+var obj = {
+  i: 10,
+  b: () =&gt; console.log(this.i, this),
+  c: function() {
+    console.log(this.i, this);
+  }
+}
+
+obj.b(); // imprime undefined, Window {...} (ou o objeto global)
+obj.c(); // imprime 10, Object {...}</code></pre>
+
+<p><em>Arrow functions</em> não tem o próprio <code>this</code>. Outro exmemplo envolvendo {{jsxref("Object.defineProperty()")}}:</p>
+
+<pre><code>'use strict';
+
+var obj = {
+  a: 10
+};
+
+Object.defineProperty(obj, 'b', {
+  get: () =&gt; {
+    console.log(this.a, typeof this.a, this); // undefined 'undefined' Window {...} (ou o objeto global)
+    return this.a + 10; // representa o objeto global 'Window', portanto 'this.a' retorna 'undefined'
+  }
+});</code></pre>
+
+<h3 id="Uso_do_operador_new">Uso do operador <code>new</code></h3>
+
+<p>Arrow functions não podem ser usadas como construtores e lançarão um erro quando usadas com o <code>new</code>.</p>
+
+<h3 id="Uso_da_propriedade_prototype">Uso da propriedade <code>prototype</code></h3>
+
+<p><em>Arrow functions</em> não têm a propriedade <code>prototype</code>.</p>
+
+<pre><code>var Foo = () =&gt; {};
+console.log(Foo.prototype); // undefined</code></pre>
+
+<h3 id="Uso_da_palavra_chave_yield">Uso da palavra chave <code>yield</code></h3>
+
+<p>A palavra chave <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/yield">yield</a></code> não pode ser usada no corpo de uma <em>arrow function</em> (exceto quando permitido dentro de funções aninhadas dentro delas). como consequência, <em>arrow functions</em> não podem ser usadas como geradoras (<em>generators</em>).</p>
+
+<h2 id="Corpo_de_função">Corpo de função</h2>
+
+<p><em>Arrow functions</em> podem ter um corpo conciso (<em>"concise body")</em> ou o usual corpo em bloco (<em>"block body")</em>.</p>
+
+<p>Em um <em>concise body</em>, apenas uma expressão é especificada, a qual se torna o valor de retorno implícito. Em um <em>block body</em>, você precisa explicitamente usar a declaração de retorno, ou seja, o <code>return</code>.</p>
+
+<pre><code>var func = x =&gt; x * x;
+// sintaxe de concise body. O "return" é implícito
+
+var func = (x, y) =&gt; { return x + y; };
+// Em um função com block body, é necessário um "return" explícito</code></pre>
+
+<h2 id="Retornando_objetos_literais">Retornando objetos literais</h2>
+
+<p>Tenha em mente que retornar objetos literais usando a sintaxe de corpo conciso (<em>concise body</em>) <code>params =&gt; {object:literal}</code> não funcionará como experado.</p>
+
+<pre><code>var func = () =&gt; { foo: 1 };
+// Chamar func() retornará undefined!
+
+var func = () =&gt; { foo: function() {} };
+// SyntaxError (Erro de sintaxe): a declaração da função requer um nome</code></pre>
+
+<p> </p>
+
+<p>Isto acontece porque o código dentro das chaves ({}) é convertido como uma sequência de sentenças (ex: <code>foo</code> é tratado como um título, não como uma chave num objeto literal).</p>
+
+<p>Se lembre de envolver o objeto literal em parênteses.</p>
+
+<pre><code>var func = () =&gt; ({foo: 1});</code>
+</pre>
+
+<h2 id="Quebras_de_linha">Quebras de linha</h2>
+
+<p>Uma <em>arrow function</em> não pode conter uma quebra de linha entre seus parâmetros e sua flecha.</p>
+
+<pre><code>var func = (a, b, c)
+           =&gt; 1;
+// SyntaxError (Erro de sintaxe): experada expressão, mas obteve '=&gt;'</code></pre>
+
+<p>Entretanto, isto pode ser corrigido ao usar parênteses ou colocar a quebra de linha dentro dos argumentos como visto abaixo para garantir que o código permaneça bonito e leve.</p>
+
+<pre class="brush: js"><code>var func = (
+  a,
+  b,
+  c
+) =&gt; (
+  1
+);
+// SyntaxError (erro de sintaxe) não é lançado</code></pre>
+
+<p> </p>
+
+<h2 id="Ordem_de_análise">Ordem de análise</h2>
+
+<p>Apesar de a flecha numa <em>arrow function</em> não ser um operador, <em>arrow functions</em> possuem regras especiais de análise que interagem diferentemente com precedência de operador (<a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">operator precedence</a>) comparadas à funções comuns.</p>
+
+<pre><code>let callback;
+
+callback = callback || function() {}; // ok
+
+callback = callback || () =&gt; {};
+// SyntaxError (Erro de sintaxe): argumentos inválidos de arrow-function
+
+callback = callback || (() =&gt; {});    // ok</code></pre>
+
+<p> </p>
+
+<h2 id="Mais_exemplos">Mais exemplos</h2>
+
+<pre><code>// Uma arrow function vazia retorna undefined
+let empty = () =&gt; {};
+
+(() =&gt; 'foobar')();
+// Retorna "foobar"
+// (esta é uma Expressão de Função Invocada Imediatamente (Immediately Invoked Function Expression)
+// veja 'IIFE' no glossário)
+
+var simple = a =&gt; a &gt; 15 ? 15 : a;
+simple(16); // 15
+simple(10); // 10
+
+let max = (a, b) =&gt; a &gt; b ? a : b;
+
+// Mapeamento, filtragem, ... simples de array
+
+var arr = [5, 6, 13, 0, 1, 18, 23];
+
+var sum = arr.reduce((a, b) =&gt; a + b);
+// 66
+
+var even = arr.filter(v =&gt; v % 2 == 0);
+// [6, 0, 18]
+
+var double = arr.map(v =&gt; v * 2);
+// [10, 12, 26, 0, 2, 36, 46]
+
+// Cadeias de promessa (<em>promisse chains</em>) mais concisas
+promise.then(a =&gt; {
+  // ...
+}).then(b =&gt; {
+  // ...
+});
+
+// Arrow functions sem parâmetros que são visualmente mais fáceis de analisar
+setTimeout( () =&gt; {
+  console.log('E aconteço antes');
+  setTimeout( () =&gt; {
+    // deeper code
+    console.log('Eu aconteço depois');
+  }, 1);
+}, 1);</code></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('ES2015', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-arrow-function-definitions', 'Arrow Function Definitions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div class="hidden">
+<p>A tabela de compatibilidade nesta página é gerada de dados estruturados. Se você quiser contribuir com os dados, por favor verifique <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande um <em>pull request</em>.</p>
+</div>
+
+<div>{{Compat("javascript.functions.arrow_functions")}}</div>
+
+<div id="compat-mobile"> </div>
diff --git a/files/pt-br/web/javascript/reference/functions/definicoes_metodos/index.html b/files/pt-br/web/javascript/reference/functions/definicoes_metodos/index.html
new file mode 100644
index 0000000000..ac02cb9deb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/functions/definicoes_metodos/index.html
@@ -0,0 +1,200 @@
+---
+title: Definições de Método
+slug: Web/JavaScript/Reference/Functions/Definicoes_metodos
+tags:
+  - ECMAScript 2015
+  - Funções
+  - JavaScript
+  - Objeto
+  - Sintaxe
+translation_of: Web/JavaScript/Reference/Functions/Method_definitions
+---
+<div>{{JsSidebar("Functions")}}</div>
+
+<p>No ECMAScript 2015 foi introduzida uma sintaxe reduzida para definição de métodos em inicializadores de objetos. É uma abreviação para uma função atribuída ao nome do método.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/functions-definitions.html")}}</p>
+
+<div class="hidden">
+<p>O código desse exemplo interativo está salvo em um repositório do GitHub. Se você quiser contribuir com o projeto de exemplos interativos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie-nos um pull request.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">var obj = {
+  <var>propriedade</var>( <var>parametros…</var> ) {},
+  *<var>generator</var>( <var>parametros…</var> ) {},
+// também com chaves computadas:
+  [<var>propriedade</var>]( <var>parameters…</var> ) {},
+  *[generator]( <var>parametros…</var> ) {},
+// compare ES5 sintaxe para getter/setter:
+  get <var>propriedade</var>() {},
+  set <var>propriedade</var>(<var>valor</var>) {}
+};
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A sintaxe reduzida é similar à da <a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">getter</a> e <a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setter</a>  introduzida no ECMAScript 5.</p>
+
+<p>Dado o seguinte código:</p>
+
+<pre class="brush: js">var obj = {
+  foo: function() {},
+  bar: function() {}
+};</pre>
+
+<p>Agora você pode reduzi-lo para isto:</p>
+
+<pre class="brush: js">var obj = {
+  foo() {},
+  bar() {}
+};</pre>
+
+<h3 id="Generator_methods">Generator methods</h3>
+
+<p>Os <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/function*">generator methods</a> também podem ser definidos utilizando a sintaxe reduzida.</p>
+
+<ul>
+ <li>Observe que o asterisco (*) na sintaxe reduzida deve estar antes do nome da propriedade generator. Assim, <code>* g(){}</code> funcionará, porém <code>g *(){}</code> não.</li>
+ <li>Se o método não for generator, sua definição não pode conter a palavra-chave <code>yield</code>. Dessa forma, <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/Generator_function_legada">generator functions legadas </a>também não funcionarão, lançando um {{jsxref("SyntaxError")}}. Sempre utilize <code>yield</code> em conjunto com o asterisco (*)</li>
+</ul>
+
+<pre class="brush: js;highlight[12]">// Utilizando a propriedade com nome (pre-ES6)
+var obj2 = {
+  g: function*() {
+    var indice = 0;
+    while(true)
+      yield indice++;
+  }
+};
+
+// O mesmo objeto utilizando a sintaxe reduzida
+var obj2 = {
+  * g() {
+    var indice = 0;
+    while(true)
+      yield indice++;
+  }
+};
+
+var coisa = obj2.g();
+console.log(coisa.next().value); // 0
+console.log(coisa.next().value); // 1</pre>
+
+<h3 id="Métodos_assíncronos">Métodos assíncronos</h3>
+
+<p>{{jsxref("Statements/funcoes_assincronas", "Funções assíncronas", "", 1)}} também podem ser definidas usando a sintaxe reduzida.</p>
+
+<pre class="brush: js;highlight[12] line-numbers  language-js"><code class="language-js"><span class="comment token">// Utilizando a propriedade com nome (pre-ES6)</span>
+<span class="keyword token">var</span> obj3 <span class="operator token">=</span> <span class="punctuation token">{</span>
+  f<span class="punctuation token">:</span> <span class="keyword token">async</span> <span class="keyword token">function</span> <span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">await</span> alguma_promise<span class="punctuation token">;</span>
+  <span class="punctuation token">}</span>
+<span class="punctuation token">}</span><span class="punctuation token">;</span>
+
+<span class="comment token">// O mesmo objeto com a sintaxe reduzida</span>
+<span class="keyword token">var</span> obj3 <span class="operator token">=</span> <span class="punctuation token">{</span>
+  <span class="keyword token">async</span> <span class="function token">f</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">await</span> alguma_promise<span class="punctuation token">;</span>
+  <span class="punctuation token">}</span>
+<span class="punctuation token">}</span><span class="punctuation token">;</span></code></pre>
+
+<h3 id="Generator_methods_assíncronos">Generator methods assíncronos</h3>
+
+<p>  Os <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/function*">generator methods</a> também podem ser {{jsxref("Statements/funcoes_assincronas", "assíncronos", "", 1)}}</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> obj4 <span class="operator token">=</span> <span class="punctuation token">{</span>
+  f<span class="punctuation token">:</span> <span class="keyword token">async</span> <span class="keyword token">function</span><span class="operator token">*</span> <span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">yield</span> <span class="number token">1</span><span class="punctuation token">;</span>
+    <span class="keyword token">yield</span> <span class="number token">2</span><span class="punctuation token">;</span>
+    <span class="keyword token">yield</span> <span class="number token">3</span><span class="punctuation token">;</span>
+  <span class="punctuation token">}</span>
+<span class="punctuation token">}</span><span class="punctuation token">;</span>
+
+<span class="comment token">// O mesmo objeto com a sintaxe reduzida</span>
+<span class="keyword token">var</span> obj4 <span class="operator token">=</span> <span class="punctuation token">{</span>
+  <span class="keyword token">async</span><span class="operator token">*</span> <span class="function token">f</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+   <span class="keyword token">yield</span> <span class="number token">1</span><span class="punctuation token">;</span>
+   <span class="keyword token">yield</span> <span class="number token">2</span><span class="punctuation token">;</span>
+   <span class="keyword token">yield</span> <span class="number token">3</span><span class="punctuation token">;</span>
+  <span class="punctuation token">}</span>
+<span class="punctuation token">}</span><span class="punctuation token">;</span></code></pre>
+
+<h3 id="Métodos_reduzidos_não_são_construíveis">Métodos reduzidos não são construíveis</h3>
+
+<p>Métodos assim definidos não são construtores e lançarão um {{jsxref("TypeError")}} se você tentar instanciá-los.</p>
+
+<pre class="brush: js">var obj = {
+  metodo() {},
+};
+new obj.metodo; // TypeError: obj.method is not a constructor
+
+var obj = {
+  * g() {}
+};
+new obj.g; // TypeError: obj.g is not a constructor (modificado no ES2016)
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Caso_de_teste_simples">Caso de teste simples</h3>
+
+<pre class="brush: js;highlight[3]">var obj = {
+  a : "foo",
+  b(){ return this.a; }
+};
+console.log(obj.b()); // "foo"
+</pre>
+
+<h3 id="Nome_de_propriedades_computados">Nome de propriedades computados</h3>
+
+<p>A sintaxe reduzida também suporta nome de propriedades computados.</p>
+
+<pre class="brush: js;highlight[4]">var bar = {
+  foo0 : function (){return 0;},
+  foo1(){return 1;},
+  ["foo" + 2](){return 2;},
+};
+
+console.log(bar.foo0()); // 0
+console.log(bar.foo1()); // 1
+console.log(bar.foo2()); // 2</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browser">Compatibilidade de browser</h2>
+
+<div class="hidden">
+<p>A tabela de compatibilidade desta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, verifique <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data </a>e envie-nos um pull request.</p>
+</div>
+
+<p>{{Compat("javascript.functions.method_definitions")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><code><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Functions/get">get</a></code></li>
+ <li><code><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Functions/set">set</a></code></li>
+ <li><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar">Gramática léxica</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/functions/get/index.html b/files/pt-br/web/javascript/reference/functions/get/index.html
new file mode 100644
index 0000000000..753f16dab0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/functions/get/index.html
@@ -0,0 +1,217 @@
+---
+title: getter
+slug: Web/JavaScript/Reference/Functions/get
+translation_of: Web/JavaScript/Reference/Functions/get
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<div>A sintaxe de <strong>get </strong>associa uma propriedade de um objeto a uma função que será chamada quando tal propriedade é acessada.</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">{get <em>prop</em>() { ... } }
+{get <em>[expression]</em>() { ... } }</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>O nome da propriedade à qual a função dada será associada.</dd>
+ <dt>expression</dt>
+ <dd>A partir do ECMAScript 6, você pode também utilizar expressões para um nome computado de uma propriedade para associar à função dada.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Às vezes é desejável que se permita acesso a uma propriedade que retorna um valor computado dinamicamente, ou você pode querer refletir o status de uma variável interna sem requerer o uso de chamadas de método explícitas. Em Javascript, isso pode ser feito com o uso de um <em>getter</em>. Não é possível simultaneamente ter um getter associado a uma propriedade e a mesma possuir um valor, embora seja possível usar um getter e um setter em conjunto para criar algo como uma pseudo-propriedade.</p>
+
+<p>Note o seguinte quando for trabalhar com a sintaxe <em>get</em>:</p>
+
+<ul>
+ <li>Pode haver um identificador que seja um número ou uma string;</li>
+ <li>Deve haver exatamente zero parâmetros (veja  <a class="external" href="http://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/" rel="external nofollow">Incompatible <abbr title="ECMAScript 5th edition">ES5</abbr> change: literal getter and setter functions must now have exactly zero or one arguments</a> para mais informações)</li>
+ <li>Não deve haver mais de um getter para a mesma propriedade nem uma propriedade comum como o mesmo nome do getter (<code>{ get x() { }, get x() { } }</code> and <code>{ x: ..., get x() { } }</code> são proibidos).</li>
+</ul>
+
+<p>Um getter pode ser removido usando o operador <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/delete" title="en/Core_JavaScript_1.5_Reference/Operators/Special_Operators/delete_Operator">delete</a>.</code></p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Definindo_um_getter_em_novos_objetos_em_inicializadores_de_objetos">Definindo um getter em novos objetos em inicializadores de objetos</h3>
+
+<p>O exemplo abaixo irá criar a pseudo-propriedade <code>latest</code> para o objeto <code>obj</code>, que irá retornar o último item do array em <code>log</code>.</p>
+
+<pre class="brush: js notranslate">var log = ['test'];
+var obj = {
+  get latest () {
+    if (log.length == 0) return undefined;
+    return log[log.length - 1]
+  }
+}
+console.log (obj.latest); // Retornará "test".
+</pre>
+
+<p>Note que a tentativa de atribuir um valor a <code>latest não irá alterá-la.</code></p>
+
+<h3 id="Removendo_um_getter_usando_o_operador_delete">Removendo um getter usando o operador <code>delete</code></h3>
+
+<p>Se você quer remover um getter, você pode apenas utilizar <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/delete">delete</a>.</code></p>
+
+<pre class="brush: js notranslate">delete obj.latest;
+</pre>
+
+<h3 id="Definindo_um_getter_em_objetos_existentes_usando_defineProperty">Definindo um getter em objetos existentes usando <code>defineProperty</code></h3>
+
+<p>Para adicionar um getter a um objeto existente a qualquer momento, use {{jsxref("Object.defineProperty()")}}.</p>
+
+<pre class="brush: js notranslate">var o = { a:0 }
+
+Object.defineProperty(o, "b", { get: function () { return this.a + 1; } });
+
+console.log(o.b) // Executa o getter, que retornará a + 1 (which is 1)</pre>
+
+<h3 id="Usando_uma_propriedade_com_nome_computado">Usando uma propriedade com nome computado</h3>
+
+<div class="note">
+<p><strong>Nota:</strong> Propriedades com nome computado são uma tecnologia experimenta, parte da proposta do ECMAScript 6 e não é amplamente suportada pelos navegadores ainda. O exemplo abaixo irá disparar um <code>SyntaxError em ambientes sem suporte.</code></p>
+</div>
+
+<pre class="brush: js notranslate">var expr = "foo";
+
+var obj = {
+  get [expr]() { return "bar"; }
+};
+
+console.log(obj.foo); // "bar"</pre>
+
+<h3 id="Smart_self-overwriting_lazy_getters">Smart / self-overwriting / lazy getters</h3>
+
+<p>Getters lhe dão uma maneira de definir uma propriedade de um objeto, mas eles não calculam o valor da propriedade até que sejam acessados. Um getter adia o custo de cálculo do valor até que o valor seja necessário e, se nunca o for, você não precisa pagar esse custo.</p>
+
+<p>Uma técnica de otimização adicional para atrasar o cálculo do valor de uma propriedade e cacheá-lo para acesso futuro são os <strong>smart ou <a href="https://en.wikipedia.org/wiki/Memoization">memoized</a> getters</strong>. O valor é calculado na primeira vez que o getter é invocado, sendo então cacheado para que acessos subsequentes retornem o valor em cache sem recalculá-lo. Isso é util nas seguintes situações:</p>
+
+<ul>
+ <li>Se o cálculo da propriedade é caro (usa muita RAM ou CPU, cria um worker, retorna um arquivo remoto, etc).</li>
+ <li>Se o valor não é necessário agora. Ele será utilizado depois ou, em alguns casos, nem mesmo o será.</li>
+ <li>Se for utilizado, ele será acessado diversas vezes e não há necessidade de recalcular um valor que nunca será alterado, ou não deveria ser recalculado.</li>
+</ul>
+
+<p>Isso significa que você não deveria utilizar um lazy getter para uma propriedade cujo valor você espera mudar, porque o getter nunca irá recalcular o valor.</p>
+
+<p>No exemplo a seguir, o objeto tem um getter como uma propriedade própria (own property). Ao tentar obter essa propriedade que foi removida, ela será readicionada, mas implicitamente como uma propriedade comum desta vez. Finalmente, o valor será retornado.</p>
+
+<pre class="brush: js notranslate">get notifier() {
+  delete this.notifier;
+  return this.notifier = document.getElementById("bookmarked-notification-anchor");
+},</pre>
+
+<p>Para o Firefox, veja também o código do módulo XPCOMUtils.jsm, que define a função <a href="/pt-BR/docs/Mozilla/JavaScript_code_modules/XPCOMUtils.jsm#defineLazyGetter()">defineLazyGetter()</a>.</p>
+
+<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('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Adicionado nomes de propriedades computadas.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome(1)}}</td>
+   <td>{{ CompatGeckoDesktop("1.8.1") }}</td>
+   <td>{{ CompatIE(9) }}</td>
+   <td>9.5</td>
+   <td>3</td>
+  </tr>
+  <tr>
+   <td>Propriedades com nome computado</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatGeckoDesktop("34") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{ CompatGeckoMobile("1.8.1") }}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Propriedades com nome computado</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatGeckoMobile("34.0") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setter</a></li>
+ <li>{{jsxref("Operators/delete", "delete")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li>
+ <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Defining Getters and Setters</a> in JavaScript Guide</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/functions/index.html b/files/pt-br/web/javascript/reference/functions/index.html
new file mode 100644
index 0000000000..41176388d1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/functions/index.html
@@ -0,0 +1,480 @@
+---
+title: Funções
+slug: Web/JavaScript/Reference/Functions
+tags:
+  - Funções
+  - JavaScript
+  - NeedsTranslation
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Functions
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>De modo geral, função é um "subprograma" que pode ser <em>chamado</em> por código externo (ou interno no caso de recursão) à função. Assim como o programa em si, uma função é composta por uma sequência de instruções chamada <em>corpo da função</em>. Valores podem ser <em>passados</em> para uma função e ela vai <em>retornar</em> um valor.</p>
+
+<p>Em JavaScript, funções são objetos de primeira classe, pois elas podem ter propriedades e métodos como qualquer outro objeto. O que as difere de outros objetos é que as funções podem ser chamados. Em resumo, elas são objetos <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function"><code>Function</code></a>.</p>
+
+<p>Para mais exemplos e explicações, veja também o <a href="/en-US/docs/Web/JavaScript/Guide/Functions">Guia de JavaScript sobre funções</a>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Toda função em JavaScript é um objeto <code>Function</code>. Veja {{jsxref("Function")}} para informação das propriedades e métodos dos objetos <code>Function</code>.</p>
+
+<p>Funções não são como procedimentos (<em>procedure</em>). Uma função sempre retorna um valor, mas um procedimento pode ou não retornar um valor.</p>
+
+<p>Para retornar um valor diferente do padrão, uma função deve ter uma instrução <a href="/en-US/docs/Web/JavaScript/Reference/Statements/return">return</a> que específica o valor a ser retornado. Uma função sem um <code>return</code> retornará um valor padrão. No caso de um <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/constructor">método construtor</a> chamado com a palavra reservada <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a>, o valor padrão é o valor do parâmetro <code>this</code>. Para todas as outras funções, o valor padrão de retorno é <code>undefined</code>.</p>
+
+<p>Os parâmetros de uma função são chamados de argumentos da função. Argumentos são passados para a função <em>por valor</em>. Se uma função muda o valor de um argumento, esta mudança não é refletida globalmente ou na chamada da função. Contudo, referência de objetos são valores também, e eles são especiais: se a função muda as propriedades do objeto referenciado, estas mudanças são visíveis fora da função, como é mostrado no exemplo a seguir:</p>
+
+<pre class="brush: js notranslate">/* Declare a função 'minhaFunção' */
+function minhaFuncao(objeto) {
+   objeto.marca = "Toyota";
+ }
+
+ /*
+  * Declare a variável 'meucarro';
+  * crie e inicialize um novo Objeto;
+  * atribua referência para 'meucarro'
+  */
+ var meucarro = {
+   marca: "Honda",
+   modelo: "Accord",
+   ano: 1998
+ };
+
+ /* Exibe 'Honda' */
+ console.log(meucarro.marca);
+
+ /* Passe a referência do objeto para a função */
+ minhaFuncao(meucarro);
+
+ /*
+  * Exibe 'Toyota' como valor para a propriedade 'marca'
+  * do objeto, mudado pela função.
+  */
+ console.log(meucarro.marca);
+</pre>
+
+<p>A palavra reservada <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/this"><code>this</code></a> não se refere a função sendo executada no momento, então você deve referenciar um objeto <code>Function</code> pelo nome, mesmo dentro do corpo da função.</p>
+
+<h2 id="Definindo_funções">Definindo funções</h2>
+
+<p>Há várias maneiras de definir funções:</p>
+
+<h3 id="Declaração_de_função_Instrução_function">Declaração de função (Instrução <code>function</code>)</h3>
+
+<p>Há um sintaxe especial para declarar funções (veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/function">Instrução function</a> para detalhes):</p>
+
+<pre class="notranslate">function <em>nome</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
+   <em>instruções</em>
+}
+</pre>
+
+<dl>
+ <dt><code>nome</code></dt>
+ <dd>O nome da função.</dd>
+</dl>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>O nome de um argumento a ser passado para a função. Uma função pode ter até 255 argumentos.</dd>
+</dl>
+
+<dl>
+ <dt><code>instruções</code></dt>
+ <dd>As instruções que formam o corpo da função.</dd>
+</dl>
+
+<h3 id="A_expressão_function_Operador_function">A expressão function (Operador <code>function</code>)</h3>
+
+<p>Uma expressão function é parecida com uma declaração function e tem até a mesma sintaxe (veja <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">Operador function</a> para detalhes):</p>
+
+<pre class="notranslate">function [<em>nome</em>]([<em>param</em>] [, <em>param</em>] [..., <em>param</em>]) {
+   <em>instruções</em>
+}
+</pre>
+
+<dl>
+ <dt><code>nome</code></dt>
+ <dd>O nome da função. Pode ser omitido, e neste caso a função é conhecida como função anônima.</dd>
+</dl>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>O nome de um argumento a ser passado para a função. Uma função pode ter até 255 argumentos.</dd>
+</dl>
+
+<dl>
+ <dt><code>instruções</code></dt>
+ <dd>As instruções que formam o corpo da função.</dd>
+</dl>
+
+<h3 id="O_gerador_de_declaração_de_função_instrução_function*">O gerador de declaração de função (instrução <code>function*</code>)</h3>
+
+<div class="note">
+<p><strong>Nota:</strong> Expressão Arrow function é uma tecnologia experimental, parte da proposta do ECMAScript 6, e ainda não é amplamente suportada pelos navegadores.</p>
+</div>
+
+<p>Uma expressão arrow function tem uma sintaxe curta e conecta seu valor lexicamente (veja <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a> para mais detalhes):</p>
+
+<pre class="notranslate">([param] [, param]) =&gt; {
+   instruções
+}
+
+param =&gt; expressão
+</pre>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>O nome de um argumento. Quando não há argumentos deve ser indicado com o uso dos parênteses ( ). Para apenas um argumento os parênteses não são obrigatórios. (por exemplo <code>foo =&gt; 1</code>)</dd>
+ <dt><code>instruções ou expressão</code></dt>
+ <dd>Múltiplas instruções precisam ser envolvidas por chaves. Uma única expressão não requer chaves. A expressão também é implicitamente o valor de retorno  dessa função.</dd>
+</dl>
+
+<h3 id="The_Function_constructor" name="The_Function_constructor">O construtor <code>Function</code></h3>
+
+<div class="note">
+<p><strong>Nota:</strong> O uso do construtor Function para criar funções não é recomendado uma vez que é requerido o corpo da função como string, o que pode impedir algumas otimizações por parte do motor JS e pode também causar outros problemas.</p>
+</div>
+
+<p>Como todos os outros objetos, objetos {{jsxref("Function")}} podem ser criados usando o operador new:</p>
+
+<pre class="notranslate">new Function (<em>arg1</em>, <em>arg2</em>, ... <em>argN</em>, <em>corpoDaFuncao</em>)
+</pre>
+
+<dl>
+ <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
+ <dd>Nenhum ou mais nomes para serem usados pela função como nomes formais de argumentos. Cada um deve ser uma string em conformidade com as regras para um identificador JavaScript válido ou uma lista com tais strings separadas por vírgula; por exemplo "x", "oValor", ou "a, b".</dd>
+</dl>
+
+<dl>
+ <dt><em>corpoDaFuncao</em></dt>
+ <dd>Uma string contento as instruções JavaScript correspondendo a definição da função.</dd>
+</dl>
+
+<p>Invocar o construtor Function como uma função (sem usar o operador new) the o mesmo efeito de invocá-lo como um construtor comum.</p>
+
+<h2 id="Parâmetros_de_Função">Parâmetros de Função</h2>
+
+<div class="note">
+<p><strong>Nota:</strong> Parâmetros Default e Rest são tecnologias experimentais, parte da proposta do ECMAScript 6, e ainda não são amplamente suportados pelos navegadores.</p>
+</div>
+
+<h3 id="Parâmetros_Default">Parâmetros Default</h3>
+
+<p>Parâmetro Default de função permite que parâmetros formais sejam inicializados com valores padrão se nenhum valor ou valor undefined é passado. Para mais detalhes, veja <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters">parâmetros default</a>.</p>
+
+<h3 id="Parâmetros_Rest">Parâmetros Rest</h3>
+
+<p>A sintaxe do parâmetro rest permite representar um número indefinido de argumentos em forma de array. Para mais detalhes, veja <a href="/en-US/docs/Web/JavaScript/Reference/Functions/rest_parameters">parâmetros rest</a>.</p>
+
+<h2 id="The_arguments_object" name="The_arguments_object">O objeto <code>arguments</code></h2>
+
+<p>Você pode referenciar aos argumentos da função dentro da função utilizando  o objeto arguments. Veja <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a>.</p>
+
+<ul>
+ <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a></code>: Um objeto array-like contendo os argumentos passados para a função atualmente  em execução.</li>
+ <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/callee">arguments.callee</a></code> {{Deprecated_inline}}: A função atualmente em execução.</li>
+ <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/caller">arguments.caller</a></code> {{Obsolete_inline}} : A função que invocou a função atualmente em execução.</li>
+ <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments/length">arguments.length</a></code>: O número de argumentos passados para a função.</li>
+</ul>
+
+<h2 id="Definindo_Métodos_de_Funções">Definindo Métodos de Funções</h2>
+
+<h3 id="Funções_Getter_e_setter">Funções Getter e setter</h3>
+
+<p>Você pode definir getters (métodos de acesso) and setters (métodos de alteração) em qualquer objeto interno padrão ou objeto definido pelo usuário que ofereça suporte à adição de novas propriedades. A sintaxe para definir getters e setters usa a sintaxe literal do objeto.</p>
+
+<dl>
+ <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">get</a></dt>
+ <dd>
+ <p>Vincula uma propriedade de objeto a uma função que será chamada quando essa propriedade é requisitada.</p>
+ </dd>
+ <dt><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">set</a></dt>
+ <dd>Vincula uma propriedade de objeto a uma função a ser chamada quando há uma tentativa de definir essa propriedade.</dd>
+</dl>
+
+<h3 id="Sintaxe_dos_métodos_de_funções">Sintaxe dos métodos de funções</h3>
+
+<div class="note">
+<p><strong>Nota:</strong> Definições de métodos são tecnologias experimentais, parte da proposta do ECMAScript 6, e ainda não são amplamente suportados pelos navegadores.</p>
+</div>
+
+<p>Começando com ECMAScript 6, você é capaz de definir métodos próprios em uma sintaxe mais curta, semelhante aos getters e setters. Veja <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Method_definitions">method definitions</a> para mais informações.</p>
+
+<pre class="brush: js notranslate">var obj = {
+  foo() {},
+  bar() {}
+};</pre>
+
+<h2 id="Function_constructor_vs._function_declaration_vs._function_expression" name="Function_constructor_vs._function_declaration_vs._function_expression"><code>Function</code> constructor vs. function declaration vs. function expression</h2>
+
+<p>Compare o seguinte:</p>
+
+<p>Uma função definida com <em><code>function</code> constructor</em> atribuiída à variável multiply</p>
+
+<pre class="brush: js notranslate">function multiply(x, y) {
+   return x * y;
+}
+</pre>
+
+<p><code>Uma </code><em>function expression</em><code> de uma função anônima atribuída à variável multiplicar</code></p>
+
+<pre class="brush: js notranslate">var multiply = function(x, y) {
+   return x * y;
+};
+</pre>
+
+<p><code>Uma </code><em>function expression </em><code>de uma função chamada func_name atribuída à variável multiplicar</code></p>
+
+<pre class="brush: js notranslate">var multiply = function func_name(x, y) {
+   return x * y;
+};
+</pre>
+
+<h3 id="Diferenças">Diferenças</h3>
+
+<p>Todas fazem aproximadamente a mesma coisa, com algumas diferenças sutis:</p>
+
+<p>Há uma distinção entre o nome da função e a variável à qual a função é atribuída. O nome da função não pode ser alterado, enquanto a variável à qual a função está atribuída pode ser reatribuída. O nome da função pode ser usado somente dentro do corpo da função. A tentativa de usá-lo fora do corpo da função resulta em um <em>error </em>(ou <em>undefined </em>se o nome da função foi declarado anteriormente por meio de uma declaração de variável). Por exemplo:</p>
+
+<pre class="brush: js notranslate">var y = function x() {};
+alert(x); // throws an error
+</pre>
+
+<p>O nome da função também aparece quando a função é serializada através do <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/toString"><code>método toString de Function()</code></a>.</p>
+
+<p>Por outro lado, a variável à qual a função é atribuída é limitada somente pelo seu escopo, garantindo-se que ele inclui o escopo onde a função é declarada.</p>
+
+<p>Como o quarto exemplo mostra, o nome da função pode ser diferente da variável à qual a função é atribuída. Eles não têm relação um com o outro. Uma declaração de função também cria uma variável com o mesmo nome da função. Assim, ao contrário daquelas definidas por expressões de função, funções definidas por declarações de função podem ser acessadas pelo seu nome no escopo onde elas foram definidas:</p>
+
+<p>Uma função definida por '<code>new Function'</code> não possui um nome. Entretanto, na máquina de JavaScript<a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, a forma serializada da função aparece como se ela tivesse o nome "anonymous". Por exemplo, <code>alert(new Function())</code> gera como saída:</p>
+
+<pre class="brush: js notranslate">function anonymous() {
+}
+</pre>
+
+<p>Já que a função na realidade não possui um nome, <code>anonymous</code> não é uma variável que possa ser acessada dentro da função. Por exemplo, o código seguinte iria resultar em um erro:</p>
+
+<pre class="brush: js notranslate">var foo = new Function("alert(anonymous);");
+foo();
+</pre>
+
+<p>Ao contrário das funções definidas por expressões de função ou pelo construtor <code>Function</code>, uma função definida por uma declaração de função pode ser usada antes da declaração da função em si. Por exemplo:</p>
+
+<pre class="brush: js notranslate">foo(); // alerts FOO!
+function foo() {
+   alert('FOO!');
+}
+</pre>
+
+<p>Uma função definida por uma expressão de função herda o escopo atual. Isto é, a função forma um closure. Por outro lado, uma função definida por um construtor<code>Function</code> não herda qualquer escopo a não ser o escopo global (que todas as funções herdam).</p>
+
+<p>Funções definidas por expressões de função e declarações de função são analisadas somente uma vez, enquanto aquelas definidas pelo construtor<code>Function</code> não são. Isto é, a string que forma o corpo da função, passada para o construtor<code>Function</code> precisa ser analisada toda vez que o construtor é chamado. Embora uma expressão de função crie um closure a cada vez, o corpo da função não é reanalisado, assim expressões de função ainda são mais rápidas do que  "<code>new Function(...)</code>". Assim, o construtor<code>Function</code> deve geralmente ser evitado sempre que possível.</p>
+
+<p>Deve ser notado, entretanto, que expressões de função e declarações de função aninhadas dentro de uma função gerada pela análise da string de um construtor<code>Function</code> não são analisadas repetidamente. Por exemplo:</p>
+
+<pre class="brush: js notranslate">var foo = (new Function("var bar = \'FOO!\';\nreturn(function() {\n\talert(bar);\n});"))();
+foo(); // O segmento "function() {\n\talert(bar);\n}" do corpo da função não é reanalisado.</pre>
+
+<p>Uma declaração de função é muito facilmente (e às vezes de forma não intencional) transformada em uma expressão de função. Uma declaração de função deixa de ser o que ela é nos casos em que:</p>
+
+<ul>
+ <li>se torna parte de uma expressão; ou</li>
+ <li>não é mais um "elemento fonte" de uma função ou do script em si. Um "elemento fonte" é uma instrução não aninhada no script ou no corpo de uma função:</li>
+</ul>
+
+<pre class="brush: js notranslate">var x = 0;               // elemento fonte
+if (x == 0) {            // elemento fonte
+   x = 10;               // não é um elemento fonte
+   function boo() {}     // não é um elemento fonte
+}
+function foo() {         // elemento fonte
+   var y = 20;           // elemento fonte
+   function bar() {}     // elemento fonte
+   while (y == 10) {     // elemento fonte
+      function blah() {} // não é um elemento fonte
+      y++;               // não é um elemento fonte
+   }
+}
+</pre>
+
+<h3 id="Examples_2">Examples</h3>
+
+<pre class="brush: js notranslate">// declaração de função
+function foo() {}
+
+// expressão de função
+(function bar() {})
+
+// expressão de função
+x = function hello() {}
+
+
+if (x) {
+   // expressão de função
+   function world() {}
+}
+
+
+// declaração de função
+function a() {
+   // declaração de função
+   function b() {}
+   if (0) {
+      // expressão de função
+      function c() {}
+   }
+}
+</pre>
+
+<h2 id="Conditionally_defining_a_function" name="Conditionally_defining_a_function">Definindo uma função condicionalmente</h2>
+
+<p>As funções podem ser definidas condicionalmente usando instruções de função (uma extensão permitida para o padrão ECMA-262 Edição 3) ou o construtor 'Function'. Observe que essas instruções de funções não são mais permitidas no ES5 strinct. Além disso, esse recurso não funciona de forma consistente em navegadores, portanto, você não deve confiar nele.</p>
+
+<p>No script a seguir, a função 'zero' nunca é definida e não pode ser chamada, porque 'if (0)' avalia sua condição como falso:</p>
+
+<pre class="brush: js notranslate">if (0) {
+   function zero() {
+      document.writeln("Isso é zero.");
+   }
+}
+</pre>
+
+<p>If the script is changed so that the condition becomes '<code>if (1)</code>', function <code>zero</code> is defined.</p>
+
+<p>Note: Although this kind of function looks like a function declaration, it is actually an expression (or statement), since it is nested within another statement. See differences between function declarations and function expressions.</p>
+
+<p>Note: Some JavaScript engines, not including <a href="/en-US/docs/SpiderMonkey">SpiderMonkey</a>, incorrectly treat any function expression with a name as a function definition. This would lead to <code>zero</code> being defined, even with the always-false <code>if</code> condition. A safer way to define functions conditionally is to define the function anonymously and assign it to a variable:</p>
+
+<pre class="brush: js notranslate">if (0) {
+   var zero = function() {
+      document.writeln("Aqui tem zero.");
+   }
+}
+</pre>
+
+<h2 id="Examples" name="Examples">Exemplo</h2>
+
+<h3 id="Example_Returning_a_formatted_number" name="Example:_Returning_a_formatted_number">Exemplo: Retornando um número formatado</h3>
+
+<p>A função a seguir retorna uma sequência contendo a representação formatada de um número preenchido com zeros à esquerda.</p>
+
+<pre class="brush: js notranslate">// Esta função retorna uma string preenchida com zeros à esquerda
+function padZeros(num, totalLen) {
+   var numStr = num.toString();             // Inicializar valor de retorno como string
+   var numZeros = totalLen - numStr.length; // Calcular números de zeros
+   for (var i = 1; i &lt;= numZeros; i++) {    // Preencher a quantidade de zeros
+      numStr = "0" + numStr;
+   }
+   return numStr; // Retorna a string já preenchida
+}
+</pre>
+
+<p>The following statements call the padZeros function.</p>
+
+<pre class="brush: js notranslate">var resultado;
+resultado = padZeros(42,4); // retorno "0042"
+resultado = padZeros(42,2); // retorno "42"
+resultado = padZeros(5,4);  // retorno "0005"
+</pre>
+
+<h3 id="Example_Determining_whether_a_function_exists" name="Example:_Determining_whether_a_function_exists">Example: Determining whether a function exists</h3>
+
+<p>You can determine whether a function exists by using the <code>typeof</code> operator. In the following example, a test is peformed to determine if the <code>window</code> object has a property called <code>noFunc</code> that is a function. If so, it is used; otherwise some other action is taken.</p>
+
+<pre class="brush: js notranslate"> if ('function' == typeof window.noFunc) {
+   // use noFunc()
+ } else {
+   // do something else
+ }
+</pre>
+
+<p>Note that in the <code>if</code> test, a reference to <code>noFunc</code> is used—there are no brackets "()" after the function name so the actual function is not called.</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. Implemented in JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-13', 'Function Definition')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>New: Arrow functions, Generator functions, default parameters, rest parameters</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function"><code>Function</code></a></li>
+ <li><a href="/en-US/docs/JavaScript/Reference/Statements/function"><code>function</code> statement</a></li>
+ <li><a href="/en-US/docs/JavaScript/Reference/Operators/function"><code>function</code> operator</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/functions/parametros_predefinidos/index.html b/files/pt-br/web/javascript/reference/functions/parametros_predefinidos/index.html
new file mode 100644
index 0000000000..82dc54abd8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/functions/parametros_predefinidos/index.html
@@ -0,0 +1,210 @@
+---
+title: Parâmetros Predefinidos
+slug: Web/JavaScript/Reference/Functions/Parametros_Predefinidos
+tags:
+  - ECMA2015
+  - ECMAScript6
+  - Function
+  - Functions
+  - Função
+  - Funções
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Functions/Default_parameters
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p><strong>Os parâmetros predefinidos de uma função</strong> permitem que parâmetros regulares sejam inicializados com com valores iniciais caso <code>undefined</code> ou nenhum valor seja passado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">function [nome]([<em>param1</em>[ = valorPredefinido1 ][, ..., <em>paramN</em>[ = valorPredefinidoN ]]]) {
+   instruções
+}
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Em JavaScript, os parâmetros de funções tem <code>{{jsxref("undefined")}}</code> como valor predefinido. Contudo, em alguns casos pode ser útil utilizar algum outro valor. É nesta situação em que os parâmetros predefinidos podem ser úteis.</p>
+
+<p>No passado, a estratégia de definir valores padrão para parâmetros era testar os valores do parâmetros no corpo da função e atribuir um valor se este for <strong><code>undefined</code>. </strong>No exemplo a seguir, se nenhum valor for fornecido para <strong>b </strong>na chamada, este valor será <code><strong>undefined</strong></code>, quando <code>a*b</code> for calculado resultaria em <code>NaN</code>. No entanto, isto é capturado na segunda linha definindo um valor padrão para b:</p>
+
+<pre class="brush: js notranslate">function multiply(a, b) {
+  b = (typeof b !== 'undefined') ? b : 1;
+
+  return a * b;
+}
+
+multiply(5, 2); // 10
+multiply(5, 1); // 5
+multiply(5);    // 5
+</pre>
+
+<p>Com o parâmetros predefinidos a checagem no corpo da função nao é mais necessária. Agora você pode simplesmente colocar 1 como valor padrão para <code>b</code> na declaração da função:</p>
+
+<pre class="brush: js notranslate">function multiply(a, b = 1) {
+  return a * b;
+}
+
+multiply(5, 2); // 10
+multiply(5, 1); // 5
+multiply(5);    // 5</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Passando_undefined_vs._outros_valores_falsy">Passando <code>undefined</code> vs. outros valores "falsy"</h3>
+
+<p>Na segunda chamada aqui, mesmo se o segundo argumento é definido explicitamente como <code>undefined</code> (com exceção de <code>null</code>) quando chamado, o valor para o argumento <code>num</code> será o padrão.</p>
+
+<pre class="notranslate"><code>function test(num = 1) {
+  console.log(typeof num);
+}
+
+test();          // 'number' (num é definido para 1)
+test(undefined); // 'number' (num é definido para 1 também)
+
+// teste com outros values "falsy":
+test('');        // 'string' (num é definido para '')
+test(null);      // 'object' (num é definido para null)</code></pre>
+
+<h3 id="Avaliado_em_tempo_de_chamada">Avaliado em tempo de chamada</h3>
+
+<p>Os parâmetros predefinidos são avaliados no momento da chamada da função, então diferente de ex.: Python, um novo objeto é criado cada vez que a funçao é chamada.</p>
+
+<pre class="brush: js notranslate">function append(value, array = []) {
+  array.push(value);
+  return array;
+}
+
+append(1); //[1]
+append(2); //[2], not [1, 2]
+
+</pre>
+
+<p>Este mesmo comportamento é aplicado para funções e variáveis:</p>
+
+<pre class="brush: js notranslate">function callSomething(thing = something()) { return thing }
+
+function something(){
+  return "sth";
+}
+
+callSomething();  //sth</pre>
+
+<h3 id="Parâmetros_predefinidos_estão_disponíveis_para_os_parâmetros_seguintes_à_sua_definição">Parâmetros predefinidos estão disponíveis para os parâmetros seguintes à sua definição</h3>
+
+<p>Parâmetros que já foram avaliados ficam disponíveis para uso para os parâmetros seguintes:</p>
+
+<pre class="brush: js notranslate">function singularAutoPlural(singular, plural = singular+"s",
+                            rallyingCry = plural + " ATTACK!!!") {
+  return [singular, plural, rallyingCry ];
+}
+
+//["Gecko","Geckos", "Geckos ATTACK!!!"]
+singularAutoPlural("Gecko");
+
+//["Fox","Foxes", "Foxes ATTACK!!!"]
+singularAutoPlural("Fox","Foxes");
+
+//["Deer", "Deer", "Deer ... change."]
+singularAutoPlural("Deer", "Deer", "Deer peaceably and respectfully
+   petition the government for positive change.")
+</pre>
+
+<p>Esta funcionalidade torna-se uma maneira direta e demonstra quantos casos extremos são manipulados.</p>
+
+<pre class="brush: js notranslate">function go() {
+  return ":P"
+}
+
+function withDefaults(a, b = 5, c = b, d = go(), e = this,
+                      f = arguments, g = this.value) {
+  return [a,b,c,d,e,f,g];
+}
+function withoutDefaults(a, b, c, d, e, f, g){
+  switch(arguments.length){
+    case 0:
+      a
+    case 1:
+      b = 5
+    case 2:
+      c = b
+    case 3:
+      d = go();
+    case 4:
+      e = this
+    case 5:
+      f = arguments
+    case 6:
+      g = this.value;
+    default:
+  }
+  return [a,b,c,d,e,f,g];
+}
+
+withDefaults.call({value:"=^_^="});
+// [undefined, 5, 5, ":P", window, arguments, "=^_^="]
+
+
+withoutDefaults.call({value:"=^_^="});
+// [undefined, 5, 5, ":P", window, arguments, "=^_^="]
+</pre>
+
+<h3 id="Funções_definidadas_dentro_do_corpo_da_função">Funções definidadas dentro do corpo da função</h3>
+
+<p>Introduzido no Gecko 33 {{geckoRelease(33)}}. Funções declaradas no corpo da função não podem ser referenciada dentro de parâmetos padrão e lançará um {{jsxref("ReferenceError")}} (atualmente um {{jsxref("TypeError")}} no SpiderMonkey, veja {{bug(1022967)}}). Parâmetros padrão são sempre executados primeiro, declarações de funções dentro do corpo de outra função são avaliadas depois.</p>
+
+<pre class="brush: js notranslate">// Não funciona! Throws ReferenceError.
+function f(a = go()) {
+  function go(){return ":P"}
+}
+</pre>
+
+<h3 id="Parâmetros_sem_valor_padrão_depois_de_parâmetros_com_valores_padrão">Parâmetros sem valor padrão depois de parâmetros com valores padrão</h3>
+
+<p>Antes do Gecko 26 {{geckoRelease(26)}}, o seguinte código resultaria em um {{jsxref("SyntaxError")}}. Isto foi corrigido no {{bug(777060)}} e funciona como esperado em versões posteriores:</p>
+
+<pre class="brush: js notranslate">function f(x=1, y) {
+  return [x, y];
+}
+
+f(); // [1, undefined]
+</pre>
+
+<h3 id="Parâmetro_desestruturado_com_valores_padrões">Parâmetro desestruturado com valores padrões</h3>
+
+<p>É possível definir valores padrões com a notação <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destructuring assignment</a>:</p>
+
+<pre class="brush: js notranslate">function f([x, y] = [1, 2], {z: z} = {z: 3}) {
+  return x + y + z;
+}
+
+f(); // 6</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-function-definitions', 'Function Definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição Inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<div>
+<p>{{Compat("javascript.functions.default_parameters")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:parameter_default_values" rel="external" title="http://wiki.ecmascript.org/doku.php?id=harmony:parameter_default_values">Original proposal at ecmascript.org</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/functions/rest_parameters/index.html b/files/pt-br/web/javascript/reference/functions/rest_parameters/index.html
new file mode 100644
index 0000000000..6bbcdacb8e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/functions/rest_parameters/index.html
@@ -0,0 +1,178 @@
+---
+title: Parâmetros Rest
+slug: Web/JavaScript/Reference/Functions/rest_parameters
+translation_of: Web/JavaScript/Reference/Functions/rest_parameters
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>A sintaxe de <strong>rest parameter (parâmetros rest)</strong>  nos permite representar um número indefinido de argumentos como um array.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush: js">function(a, b, ...theArgs) {
+  // ...
+}
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se o último argumento nomeado de uma função tiver prefixo com  <code>...</code>, ele irá se tornar um array em que os elemento de 0 (inclusive) até theArgs.length (exclusivo) são disponibilizados pelos argumentos atuais passados à função.</p>
+
+<p>No exemplo acima, <code>theArgs</code> irá coletar o terceiro argumento da função (porquê o primeiro é mapeado para <code>a</code>, e o segundo para <code>b</code>) e assim por diante em todos os argumentos consecutivos.</p>
+
+<h3 id="Diferença_entre_rest_parameters_e_arguments_object">Diferença entre <em>rest parameters</em> e <em><code>arguments</code> object</em></h3>
+
+<p>Há três diferenças principais entre <em>rest parameters</em> e os <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments" title="arguments"><code>arguments</code></a> objects:</p>
+
+<ul>
+ <li><em>rest parameters</em> são os únicos que não foram atribuidos a um nome separado, enquanto os <code>arguments</code> object contêm todos os argumentos passados para a função;</li>
+ <li>o objeto <code>arguments</code> não é um array, enquanto  rest parameters são instâncias <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="Array"><code>Array</code></a>,  isso significa que métodos como <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort" title="Array sort method"><code>sort</code></a>, <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map" title="Array map method"><code>map</code></a>, <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach" title="Array forEach method"><code>forEach</code></a> ou <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop" title="Array pop method"><code>pop</code></a> podem ser aplicados diretamente;</li>
+ <li> o objeto <code>arguments</code> possui a funcionalidade adicional de especificar ele mesmo (como a propriedade <code>callee</code>). </li>
+</ul>
+
+<h3 id="De_arguments_para_array">De arguments para array</h3>
+
+<p>Rest parameters foram criados para reduzir o <span id="result_box" lang="pt"><span>código padrão</span> <span>que</span> <span>foi induzida</span> <span>pelos argumentos</span></span></p>
+
+<pre class="brush: js">// Antes rest parameters, o seguinte codigo pode ser encontrado
+function f(a, b){
+  var args = Array.prototype.slice.call(arguments, f.length);
+
+  // ...
+}
+
+// esse é o equivalente
+
+function(a, b, ...args) {
+
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Como  <code>theArgs</code> é um array, você pode pegar número de elementos usando a propriedade <code>length</code>:</p>
+
+<pre class="brush: js">function fun1(...theArgs) {
+  console.log(theArgs.length);
+}
+
+fun1();  // 0
+fun1(5); // 1
+fun1(5, 6, 7); // 3
+</pre>
+
+<p>No próximo exemplo, nós usamos o rest parâmetro para buscar argumentos do segundo parâmetro para o fim. Nós multiplicamos eles pelo primeiro parâmetro:</p>
+
+<pre class="brush: js">function multiply(multiplier, ...theArgs) {
+  return theArgs.map(function (element) {
+    return multiplier * element;
+  });
+}
+
+var arr = multiply(2, 1, 2, 3);
+console.log(arr); // [2, 4, 6]
+</pre>
+
+<p>O próximo exemplo mostra como você pode usar metodos do Array em rest params, mas não no objeto <code>arguments</code>:</p>
+
+<pre class="brush: js">function sortRestArgs(...theArgs) {
+  var sortedArgs = theArgs.sort();
+  return sortedArgs;
+}
+
+console.log(sortRestArgs(5,3,7,1)); // Exibe 1,3,5,7
+
+function sortArguments() {
+  var sortedArgs = arguments.sort();
+  return sortedArgs; // isso nunca irá ocorrer
+}
+
+// throws a TypeError: arguments.sort is not a function
+console.log(sortArguments(5,3,7,1));
+</pre>
+
+<p>a fim de usar o objeto <code>arguments</code>, você precisará converte-lo para um array antes.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-definitions', 'Function Definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(47)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("15.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(45)}}</td>
+   <td>{{CompatGeckoMobile("15.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(47)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments" title="arguments">Arguments object</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="Array">Array</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions" title="Functions and function scope">Functions</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator" title="spread operator">Spread Operator</a></li>
+ <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:rest_parameters">Original proposal at ecmascript.org</a></li>
+ <li><a class="external" href="http://javascriptweblog.wordpress.com/2011/01/18/javascripts-arguments-object-and-beyond/">JavaScript arguments object and beyond</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/functions/set/index.html b/files/pt-br/web/javascript/reference/functions/set/index.html
new file mode 100644
index 0000000000..0862565bee
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/functions/set/index.html
@@ -0,0 +1,210 @@
+---
+title: setter
+slug: Web/JavaScript/Reference/Functions/set
+translation_of: Web/JavaScript/Reference/Functions/set
+---
+<div>{{jsSidebar("Functions")}}</div>
+
+<p>A sintaxe <em><strong><code>set</code></strong></em> liga a propriedade da função para ser chamada quando existe uma tentativa de definir valor para essa propriedade.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">{set <em>prop</em>(<em>val</em>) { . . . }}
+{set [expression](<em>val</em>) { . . . }}</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Nome da propriedade ligada a função.</dd>
+</dl>
+
+<dl>
+ <dt><code>val</code></dt>
+ <dd><code><font face="Open Sans, Arial, sans-serif">Um apelido para variável que será atribuidada a prop</font>.</code></dd>
+ <dt>expression</dt>
+ <dd>Iniciando com ECMAScript 6, você pode usar também expressões para computar o nome da propriedade a ser definida na função.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Em JavaScript, um <em>setter </em>pode ser usado para executar uma função sempre que se tenta mudar uma propriedade específica. <em>Setters </em>são geralmente usados em conjunto com <em>getters</em>, para criar um tipo de pseudo-propriedade. No entanto é impossível ter-se um setter para uma propriedade que contenha um valor real.</p>
+
+<p>Observe os seguintes itens ao trabalhar com a sintaxe <em>set</em>:</p>
+
+<div>
+<ul>
+ <li>Ele pode ter um identificador que é um número ou uma string;</li>
+ <li>Deve ter exatamente um parâmetro (para mais informações, acesse: <a class="external" href="http://whereswalden.com/2010/08/22/incompatible-es5-change-literal-getter-and-setter-functions-must-now-have-exactly-zero-or-one-arguments/" rel="external nofollow">Mudança do <abbr title="ECMAScript 5th edition">ES5 incompatível</abbr>: funções getter e setter literais tem exatamemente zero ou um parâmetros</a>);</li>
+ <li>Não deve ter a mesma nomenclatura seja ela para propriedades ou função.<br>
+  (<code>{ set x(v) { }, set x(v) { } }</code> e <code>{ x: ..., set x(v) { } }</code> é proibido.)</li>
+</ul>
+</div>
+
+<p>Um <em>setter </em>pode ser deletado usando o operator <a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete" title="en-US/docs/JavaScript/Reference/Operators/Special/delete"><code>delete</code></a>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Definindo_um_setter_em_new_Objects_no_inicializador">Definindo um setter em new Objects no inicializador</h3>
+
+<p>Vai definir um pseudo-property <em>current </em>para este objeto,  quando atribuido um valor, vai mudar <code>log</code> com o valor passado:</p>
+
+<pre class="brush: js">var o = {
+  set current (str) {
+    this.log[this.log.length] = str;
+  },
+  log: []
+}
+</pre>
+
+<p>Observer que <em>current </em>não está definido e qualquer tentativa de acesso irá resultar em <em>undefined</em>.</p>
+
+<h3 id="Removendo_um_setter_com_o_operador_delete">Removendo um setter com o operador <code>delete</code></h3>
+
+<p>Se você deseja remover o <em>setter</em>, poderá usar somente o <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code>:</p>
+
+<pre class="brush: js">delete o.current;
+</pre>
+
+<h3 id="Definindo_um_setter_para_um_Object_existente_usando_o_defineProperty">Definindo um setter para um Object existente usando o <code>defineProperty</code></h3>
+
+<p>Para adicionar um <em>setter </em>para um Object existentem mais tarde, use {{jsxref("Object.defineProperty()")}}.</p>
+
+<pre class="brush: js">var o = { a:0 };
+
+Object.defineProperty(o, "b", { set: function (x) { this.a = x / 2; } });
+
+o.b = 10; // Runs the setter, which assigns 10 / 2 (5) to the 'a' property
+console.log(o.a) // 5</pre>
+
+<h3 id="Usando_um_nome_de_propriedade_computada">Usando um nome de propriedade computada</h3>
+
+<div class="note">
+<p><strong>Atenção:</strong> Propriedades computadas são uma tecnologia experimental, parte da proposta ECMAScript 6, e não é amplamente suportada por todos os browsers ainda. Ele vai retornar um syntax error en ambientes que não tem suporte.</p>
+</div>
+
+<pre class="brush: js">var expr = "foo";
+
+var obj = {
+  baz: "bar",
+  set [expr](v) { this.baz = v; }
+};
+
+console.log(obj.baz); // "bar"
+obj.foo = "baz";      // run the setter
+console.log(obj.baz); // "baz"
+</pre>
+
+<h2 id="Expecificações">Expecificaçõ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>{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-method-definitions', 'Method definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Added computed property names.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-method-definitions', 'Method definitions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(1)}}</td>
+   <td>{{ CompatGeckoDesktop("1.8.1") }}</td>
+   <td>{{ CompatIE(9) }}</td>
+   <td>9.5</td>
+   <td>3</td>
+  </tr>
+  <tr>
+   <td>Computed property names</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatGeckoDesktop("34") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{ CompatGeckoMobile("1.8.1") }}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Computed property names</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatGeckoMobile("34.0") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="SpiderMonkey-specific_notes">SpiderMonkey-specific notes</h2>
+
+<ul>
+ <li>Starting with<a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.8.1"> JavaScript 1.8.1</a>, setters are no longer called when setting properties in object and array initializers.</li>
+ <li>From SpiderMonkey 38 on, a setter with a {{jsxref("Functions/rest_parameters", "rest parameter", "", 1)}} is a {{jsxref("SyntaxError")}} as per the ES6 specification.</li>
+</ul>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">getter</a></li>
+ <li>{{jsxref("Operators/delete", "delete")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.defineGetter", "__defineGetter__")}}</li>
+ <li>{{jsxref("Object.defineSetter", "__defineSetter__")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Defining Getters and Setters</a> in JavaScript Guide</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html b/files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html
new file mode 100644
index 0000000000..4256678efd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/@@iterator/index.html
@@ -0,0 +1,122 @@
+---
+title: 'Array.prototype[@@iterator]()'
+slug: Web/JavaScript/Reference/Global_Objects/Array/@@iterator
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@iterator
+---
+<div>{{JSRef}}</div>
+
+<p>O valor inicial da propriedade <code><strong>@@iterator</strong></code> é o mesmo objeto função que o valor inicial da propriedade {{jsxref("Array.prototype.values()", "values()")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>[Symbol.iterator]()</code></pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Iteração_usando_laço_for...of">Iteração usando laço <code>for...of</code></h3>
+
+<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
+// seu navegador deve suportar laço for..of
+// e variáveis de escopo let em laços for
+for (let letter of arr) {
+  console.log(letter);
+}
+</pre>
+
+<h3 id="Iteração_alternativa">Iteração alternativa</h3>
+
+<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
+var eArr = arr[Symbol.iterator]();
+console.log(eArr.next().value); // w
+console.log(eArr.next().value); // y
+console.log(eArr.next().value); // k
+console.log(eArr.next().value); // o
+console.log(eArr.next().value); // p
+</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-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype-@@iterator', 'Array.prototype[@@iterator]()')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("38")}}</td>
+   <td>{{CompatGeckoDesktop("36")}} [1]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("25")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("36")}} [1]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("25")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] A partir do Gecko 17 (Firefox 17 / Thunderbird 17 / SeaMonkey 2.14) até o Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2) a propriedade <code>iterator</code> era usada (<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=907077">bug 907077</a>), e a partir do Gecko 27 até o Gecko 35 o placeholder <code>"@@iterator"</code> era usado. No Gecko 36 (Firefox 36 / Thunderbird 36 / SeaMonkey 2.33), o <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Symbol">símbolo</a> <code>@@iterator</code> foi implementado (<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918828">bug 918828</a>).</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.keys()")}}</li>
+ <li>{{jsxref("Array.prototype.entries()")}}</li>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+ <li>{{jsxref("Array.prototype.some()")}}</li>
+ <li>{{jsxref("Array.prototype.values()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html b/files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html
new file mode 100644
index 0000000000..53805d6ada
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/@@unscopables/index.html
@@ -0,0 +1,75 @@
+---
+title: 'Array.prototype[@@unscopables]'
+slug: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables
+tags:
+  - ES2015
+  - JS
+  - Propriedade
+  - Prototipo
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/@@unscopables
+---
+<div>{{JSRef}}</div>
+
+<div>A propriedade de símbolo <code><strong>@@unscopable</strong></code> contém nomes de propriedades que não foram incluídos no padrão ECMAScript antes da versão ES2015. Essas propriedades são excluídas do statement bindings <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code>. </div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>arr</var>[Symbol.unscopables]</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>As propriedades padrão de array que são excluídas dos bindings <code>with</code> são: copyWithin, entries, fill, find, findIndex, includes, keys, e values.</p>
+
+<p>Veja {{jsxref("Symbol.unscopables")}} para saber como definir <code>unscopables</code> para seus objetos.</p>
+
+<p>{{js_property_attributes(0,0,1)}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>O código a seguir funciona bem no ES5 e abaixo. No entanto, no ECMAScript 2015 e posterior, o método {{jsxref("Array.prototype.keys()")}} foi introduzido. Isso significa que dentro de ambientes <code>with</code>, as "keys" seriam agora o método e não a variável. É aqui que a propriedade de símbolo <code>@@unscopables</code> <code>Array.prototype[@@unscopables]</code> entra em ação e impede que alguns métodos do Array estejam sendo definidos na instrução <code>with</code>.</p>
+
+<pre class="brush: js">var keys = [];
+
+with (Array.prototype) {
+  keys.push('alguma coisa');
+}
+
+Object.keys(Array.prototype[Symbol.unscopables]);
+// ["copyWithin", "entries", "fill", "find", "findIndex",
+//  "includes", "keys", "values"]</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('ES2015', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype-@@unscopables', 'Array.prototype[@@unscopables]')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Array.@@unscopables")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Symbol.unscopables")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/concat/index.html b/files/pt-br/web/javascript/reference/global_objects/array/concat/index.html
new file mode 100644
index 0000000000..dc8fc20d38
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/concat/index.html
@@ -0,0 +1,159 @@
+---
+title: Array.prototype.concat()
+slug: Web/JavaScript/Reference/Global_Objects/Array/concat
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O método concat() retorna um novo array contendo todos os arrays ou valores passados como parâmetro</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>arr</em>.concat(<em>valor1</em>, <em>valor2</em>, ..., <em>valorN</em>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><font face="Courier New, Andale Mono, monospace"><span style="line-height: normal;">valorN</span></font></dt>
+ <dd>Arrays ou valores para concatenar (unir) ao array retornado.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><strong>concat </strong>cria um novo array unindo todos os elementos que foram passados como parâmetro, na ordem dada, para cada argumento e seus elementos (se o elemento passado for um array).</p>
+
+<p><strong>concat </strong>não altera a si mesmo ou a qualquer um dos argumentos passados, apenas providencia um novo array contendo uma cópia de si mesmo e dos argumentos passados. Os elementos copiados são:</p>
+
+<ul>
+ <li>Referência aos objetos (e não o objeto): concat copia a referência aos objetos para o novo array. Tanto o original quanto a cópia apontam para o mesmo objeto. Ou seja, se o objeto foi modificado, tais mudanças serão visíveis no objeto original e no array.</li>
+</ul>
+
+<ul>
+ <li>Strings e numbers (diferente dos objetos {{jsxref("Global_Objects/String", "String")}} e {{jsxref("Global_Objects/Number", "Number")}}): <code>concat</code> copia os valores de strings e numbers para o novo array. Qualquer alteração no novo array não refletirá no original, e vice versa.</li>
+</ul>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Concatenating_two_arrays" name="Example:_Concatenating_two_arrays">Exemplo: Concatenando dois arrays</h3>
+
+<p>O código a seguir une dois arrays:</p>
+
+<pre class="brush: js">var alpha = ["a", "b", "c"];
+var numeric = [1, 2, 3];
+
+// creates array ["a", "b", "c", 1, 2, 3]; alpha and numeric are unchanged
+var alphaNumeric = alpha.concat(numeric);
+</pre>
+
+<h3 id="Example:_Concatenating_three_arrays" name="Example:_Concatenating_three_arrays">Exemplo: Concatenando três arrays</h3>
+
+<p>O código a seguir une três arrays:</p>
+
+<pre class="brush: js">var num1 = [1, 2, 3];
+var num2 = [4, 5, 6];
+var num3 = [7, 8, 9];
+
+// creates array [1, 2, 3, 4, 5, 6, 7, 8, 9]; num1, num2, num3 are unchanged
+var nums = num1.concat(num2, num3);
+</pre>
+
+<h3 id="Example:_Concatenating_values_to_an_array" name="Example:_Concatenating_values_to_an_array">Exemplo: Concatenando valores ao array</h3>
+
+<p>O código a seguir une três valores ao array</p>
+
+<pre class="brush: js">var alpha = ['a', 'b', 'c'];
+
+// creates array ["a", "b", "c", 1, 2, 3], leaving alpha unchanged
+var alphaNumeric = alpha.concat(1, [2, 3]);
+</pre>
+
+<h2 id="Especificação">Especificação</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 3rd Edition</td>
+   <td>Standard</td>
+   <td>Initial definition.<br>
+    Implemented in JavaScript 1.2</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.4', 'Array.prototype.concat')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.concat', 'Array.prototype.concat')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_navegadores">Compatibilidade em navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>1.0</td>
+   <td>{{CompatGeckoDesktop("1.7")}}</td>
+   <td>5.5</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.push", "push")}} / {{jsxref("Array.pop", "pop")}} - add/remove elements from the end of the array;</li>
+ <li>{{jsxref("Array.unshift", "unshift")}} / {{jsxref("Array.shift", "shift")}} - add/remove elements from the beginning of the array;</li>
+ <li>{{jsxref("Array.splice", "splice")}} - add/remove elements from the specified location of the array.</li>
+ <li>{{jsxref("String.prototype.concat")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/contains/index.html b/files/pt-br/web/javascript/reference/global_objects/array/contains/index.html
new file mode 100644
index 0000000000..a0f794df1a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/contains/index.html
@@ -0,0 +1,106 @@
+---
+title: Array.prototype.includes()
+slug: Web/JavaScript/Reference/Global_Objects/Array/contains
+tags:
+  - Array
+  - ECMAScript7
+  - Experimental
+  - Expérimental(2)
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Sumário">Sumário</h2>
+
+<p><span class="seoSummary">O método includes<code>()</code> determina se um array contém um determinado elemento, retornando <code>true</code> ou <code>false</code> apropriadamente.</span></p>
+
+<p><strong style="font-size: 2.14285714285714rem; font-weight: 700; letter-spacing: -1px; line-height: 30px;">Sintaxe</strong></p>
+
+<pre class="syntaxbox"><code><var>array</var>.includes(<var>searchElement</var>[, <var>fromIndex</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>searchElement</code></dt>
+ <dd>O elemento a buscar</dd>
+ <dt><code>fromIndex</code></dt>
+ <dd>Opcional. A posição no array de onde a busca pelo <code>searchElement </code>se iniciará. Por padrão, 0.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">[1, 2, 3].includes(2);     // true
+[1, 2, 3].includes(4);     // false
+[1, 2, 3].includes(3, 3);  // false
+[1, 2, 3].includes(3, -1); // true
+[1, 2, NaN].includes(NaN); // true
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.includes
+if (!Array.prototype.includes) {
+  Object.defineProperty(Array.prototype, 'includes', {
+    value: function(searchElement, fromIndex) {
+
+      // 1. Let O be ? ToObject(this value).
+      if (this == null) {
+        throw new TypeError('"this" is null or not defined');
+      }
+
+      var o = Object(this);
+
+      // 2. Let len be ? ToLength(? Get(O, "length")).
+      var len = o.length &gt;&gt;&gt; 0;
+
+      // 3. If len is 0, return false.
+      if (len === 0) {
+        return false;
+      }
+
+      // 4. Let n be ? ToInteger(fromIndex).
+      //    (If fromIndex is undefined, this step produces the value 0.)
+      var n = fromIndex | 0;
+
+      // 5. If n ≥ 0, then
+      //  a. Let k be n.
+      // 6. Else n &lt; 0,
+      //  a. Let k be len + n.
+      //  b. If k &lt; 0, let k be 0.
+      var k = Math.max(n &gt;= 0 ? n : len - Math.abs(n), 0);
+
+      // 7. Repeat, while k &lt; len
+      while (k &lt; len) {
+        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
+        // b. If SameValueZero(searchElement, elementK) is true, return true.
+        // c. Increase k by 1.
+        // NOTE: === provides the correct "SameValueZero" comparison needed here.
+        if (o[k] === searchElement) {
+          return true;
+        }
+        k++;
+      }
+
+      // 8. Return false
+      return false;
+    }
+  });
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Proposta ES7: <a href="https://github.com/domenic/Array.prototype.contains/blob/master/spec.md">https://github.com/domenic/Array.prototype.contains/blob/master/spec.md</a></p>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<div>{{Compat("javascript.builtins.Array.includes")}}</div>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("TypedArray.prototype.includes()")}}</li>
+ <li>{{jsxref("String.prototype.includes()")}}</li>
+ <li>{{jsxref("Array.prototype.indexOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html b/files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html
new file mode 100644
index 0000000000..4802e87b94
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/copywithin/index.html
@@ -0,0 +1,203 @@
+---
+title: Array.prototype.copyWithin()
+slug: Web/JavaScript/Reference/Global_Objects/Array/copyWithin
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/copyWithin
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>copyWithin()</strong></code> copia parte de um array para outra localização dentro deste mesmo array e o retorna, sem alterar seu tamanho. </p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.copyWithin(<var>target</var>, <var>start</var>[, <var>end</var> = this.length])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>target</code></dt>
+ <dd>Posição para a qual os elementos serão copiados. Caso negativo, o <code>target</code> será contado a partir do final.</dd>
+ <dt><code>start</code></dt>
+ <dd>Índice inicial de onde se copiará os elementos. Caso negativo, o <code>start</code> será contado a partir do final.</dd>
+ <dt><code>end </code>{{optional_inline}}</dt>
+ <dd>Índice final de onde se copiará os elementos. Caso negativo, o <code>end</code> será contado a partir do final.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Os argumentos <code>target</code>, <code>start</code> e <code>end</code> são restritos a {{jsxref("Number")}} e truncados para valores inteiros.</p>
+
+<p>Se <code>start</code> for negativo, ele é tratado como <code>length+start</code>, onde <code>length</code> é o comprimento do array. Se <code>end</code> for negativo, ele é tratado como <code>length+end</code>.</p>
+
+<p>A função <code>copyWithin</code> é intencionalmente <em>genérica</em>, não requer que seu valor <code>this</code> seja um objeto {{jsxref("Array")}} e, adicionalmente, <code>copyWithin</code> é um <em>método mutável</em>, irá mudar o próprio objeto <code>this</code> e retorná-lo, não apenas retornar uma cópia dele.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">[1, 2, 3, 4, 5].copyWithin(0, 3);
+// [4, 5, 3, 4, 5]
+
+[1, 2, 3, 4, 5].copyWithin(0, 3, 4);
+// [4, 2, 3, 4, 5]
+
+[1, 2, 3, 4, 5].copyWithin(0, -2, -1);
+// [4, 2, 3, 4, 5]
+
+[].copyWithin.call({length: 5, 3: 1}, 0, 3);
+// {0: 1, 3: 1, length: 5}
+
+// Typed Arrays do ES6 são subclasses de Array
+var i32a = new Int32Array([1, 2, 3, 4, 5]);
+
+i32a.copyWithin(0, 2);
+// Int32Array [3, 4, 5, 4, 5]
+
+// Em plataformas que ainda não são compatíveis com ES6:
+[].copyWithin.call(new Int32Array([1, 2, 3, 4, 5]), 0, 3, 4);
+// Int32Array [4, 2, 3, 4, 5]
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">if (!Array.prototype.copyWithin) {
+  Array.prototype.copyWithin = function(target, start/*, end*/) {
+    // Passos 1-2.
+    if (this == null) {
+      throw new TypeError('this é null ou não definido');
+    }
+
+    var O = Object(this);
+
+    // Passos 3-5.
+    var len = O.length &gt;&gt;&gt; 0;
+
+    // Passos 6-8.
+    var relativeTarget = target &gt;&gt; 0;
+
+    var to = relativeTarget &lt; 0 ?
+      Math.max(len + relativeTarget, 0) :
+      Math.min(relativeTarget, len);
+
+    // Passos 9-11.
+    var relativeStart = start &gt;&gt; 0;
+
+    var from = relativeStart &lt; 0 ?
+      Math.max(len + relativeStart, 0) :
+      Math.min(relativeStart, len);
+
+    // Passos 12-14.
+    var end = arguments[2];
+    var relativeEnd = end === undefined ? len : end &gt;&gt; 0;
+
+    var final = relativeEnd &lt; 0 ?
+      Math.max(len + relativeEnd, 0) :
+      Math.min(relativeEnd, len);
+
+    // Passo 15.
+    var count = Math.min(final - from, len - to);
+
+    // Passos 16-17.
+    var direction = 1;
+
+    if (from &lt; to &amp;&amp; to &lt; (from + count)) {
+      direction = -1;
+      from += count - 1;
+      to += count - 1;
+    }
+
+    // Passo 18.
+    while (count &gt; 0) {
+      if (from in O) {
+        O[to] = O[from];
+      } else {
+        delete O[to];
+      }
+
+      from += direction;
+      to += direction;
+      count--;
+    }
+
+    // Passo 19.
+    return O;
+  };
+}
+</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-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.copyWithin', 'Array.prototype.copyWithin')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("45")}}</td>
+   <td>{{CompatGeckoDesktop("32")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("32")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/entries/index.html b/files/pt-br/web/javascript/reference/global_objects/array/entries/index.html
new file mode 100644
index 0000000000..8abb0cf088
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/entries/index.html
@@ -0,0 +1,117 @@
+---
+title: Array.prototype.entries()
+slug: Web/JavaScript/Reference/Global_Objects/Array/entries
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/entries
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>entries()</strong></code> retorna um novo objeto <code><strong>Array Iterator</strong></code> que contém os pares chave/valor para cada índice no array.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.entries()</code></pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush:js">var arr = ['a', 'b', 'c'];
+var eArr = arr.entries();
+
+console.log(eArr.next().value); // [0, 'a']
+console.log(eArr.next().value); // [1, 'b']
+console.log(eArr.next().value); // [2, 'c']
+</pre>
+
+<h3 id="O_mesmo_que_acima_utilizando_um_loop_for…of">O mesmo que acima, utilizando um loop <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Statements/for...of">for…of</a></h3>
+
+<pre class="brush:js">var arr = ['a', 'b', 'c'];
+var eArr = arr.entries();
+
+for (let e of eArr) {
+  console.log(e);
+}
+// [0, 'a']
+// [1, 'b']
+// [2, 'c']</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-array.prototype.entries', 'Array.prototype.entries')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.entries', 'Array.prototype.entries')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("38")}}</td>
+   <td>{{CompatGeckoDesktop("28")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("25")}}</td>
+   <td>{{CompatSafari("7.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("28")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8.0</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.keys()")}}</li>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+ <li>{{jsxref("Array.prototype.some()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/every/index.html b/files/pt-br/web/javascript/reference/global_objects/array/every/index.html
new file mode 100644
index 0000000000..a7d290e58a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/every/index.html
@@ -0,0 +1,176 @@
+---
+title: Array.prototype.every()
+slug: Web/JavaScript/Reference/Global_Objects/Array/every
+tags:
+  - Array
+  - JavaScript
+  - Método(2)
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/every
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>every() </strong>testa se todos os elementos do array passam pelo teste implementado pela função fornecida.</code></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.every(<var>callback</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função que testa cada elemento, recebe três parametros:
+ <dl>
+  <dt><code>currentValue</code> (obrigatório)</dt>
+  <dd>O elemento atual sendo processado na array. </dd>
+  <dt><code>index</code> (opcional)</dt>
+  <dd>O índice do elemento atual sendo processado na array.</dd>
+  <dt><code>array</code> (opcional)</dt>
+  <dd>O array de origem.</dd>
+ </dl>
+ </dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Opcional. Valor a ser usado como <code>this</code> quando o <code>callback</code> é executado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p><strong>true</strong> se a função de callback retorna um valor {{Glossary("truthy")}} para cada um dos elementos do array; caso contrário, <strong>false</strong>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>every </code>executa a função <code>callback </code>fornecida uma vez para cada elemento presente no array, até encontrar algum elemento em que a função retorne um valor false (valor que se torna false quando convertido para boolean). Se esse elemento é encontrado, o método <code>every </code>imediatamente retorna false. Caso contrário, se a função <code>callback </code>retornar true para todos elementos, o método retorna true.  A função <code>callback</code> é chamada apenas para os elementos do array original que tiverem valores atribuídos; os elementos que tiverem sido removidos ou os que nunca tiveram valores atribuídos não serão considerados.</p>
+
+<p>A função <code>callback</code> é chamada com três argumentos: o valor do elemento corrente, o índice do elemento corrente e o array original que está sendo percorrido.</p>
+
+<p>Se o parâmetro <code>thisArg</code> foi passado para o método <code>every</code>, ele será repassado para a função <code>callback</code> no momento da chamada para ser utilizado como o <code>this</code>. Caso contrário, o valor <code>undefined </code>será repassado para uso como o <em><code>this</code></em>. O valor do <code>this</code> a ser repassado para o <code>callback</code> é determinado de acordo com as <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/this">regras usuais para determinar o this visto por uma função</a>.</p>
+
+<p>O método <code>every </code>não modifica o array original.</p>
+
+<p>A lista de elementos que serão processados pelo <font face="Consolas, Liberation Mono, Courier, monospace"><code>every</code> </font>é montada antes da primeira chamada da função <code>callback</code>. Se um elemento for acrescentado ao array original após a chamada ao <code>every</code> , ele não será visível para o callback. Se os elementos existentes forem modificados, os valores que serão repassados serão os do momento em que o método <code>every</code> chamar o <code>callback</code>. Elementos removidos não serão considerados.</p>
+
+<p><code>every</code> funciona como o  qualificador "for all" em matemática. Particularmente, para um vetor vazio, é retornado true. (<a href="https://pt.wikipedia.org/wiki/Verdade_por_vacuidade">É verdade por vacuidade</a> que todos os elementos do <a href="https://pt.wikipedia.org/wiki/Conjunto_vazio">conjunto vazio</a> satisfazem qualquer condição.)</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Testando_tamanho_de_todos_os_elementos_do_vetor">Testando tamanho de todos os elementos do vetor</h3>
+
+<p>O exemplo a seguir testa se todos elementos no array são maiores que 10.</p>
+
+<pre class="brush: js">function isBigEnough(element, index, array) {
+  return element &gt;= 10;
+}
+[12, 5, 8, 130, 44].every(isBigEnough);   // false
+[12, 54, 18, 130, 44].every(isBigEnough); // true
+</pre>
+
+<h3 id="Usando_arrow_functions">Usando arrow functions</h3>
+
+<p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Arrow functions</a> fornecem sintaxe mais curta para o mesmo teste. </p>
+
+<pre class="brush: js">[12, 5, 8, 130, 44].every(elem =&gt; elem &gt;= 10); // false
+[12, 54, 18, 130, 44].every(elem =&gt; elem &gt;= 10); // true</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p><code>every</code> foi adicionado ao padrão ECMA-262 na 5ª edição; como tal, pode não estar presente em outras implementações do padrão. Você pode contornar isso adicionando o seguinte código no começo dos seus scripts, permitindo o uso de every em implementações que não o suportam nativamente. Esse algoritimo é exatamente o mesmo especificado no ECMA-262, 5ª edição, assumindo que <code>Object e<font face="Open Sans, arial, x-locale-body, sans-serif"> </font></code><code>TypeError tem os seus valores originais e que</code> <code>callbackfn.call retorna o valor original de </code>{{jsxref("Function.prototype.call")}}</p>
+
+<pre class="brush: js">if (!Array.prototype.every) {
+  Array.prototype.every = function(callbackfn, thisArg) {
+    'use strict';
+    var T, k;
+
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+
+    // 1. Let O be the result of calling ToObject passing the this
+    //    value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal method
+    //    of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length &gt;&gt;&gt; 0;
+
+    // 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
+    if (typeof callbackfn !== 'function') {
+      throw new TypeError();
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if (arguments.length &gt; 1) {
+      T = thisArg;
+    }
+
+    // 6. Let k be 0.
+    k = 0;
+
+    // 7. Repeat, while k &lt; len
+    while (k &lt; len) {
+
+      var kValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal
+      //    method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal method
+        //    of O with argument Pk.
+        kValue = O[k];
+
+        // ii. Let testResult be the result of calling the Call internal method
+        //     of callbackfn with T as the this value and argument list
+        //     containing kValue, k, and O.
+        var testResult = callbackfn.call(T, kValue, k, O);
+
+        // iii. If ToBoolean(testResult) is false, return false.
+        if (!testResult) {
+          return false;
+        }
+      }
+      k++;
+    }
+    return true;
+  };
+}
+</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('ES5.1', '#sec-15.4.4.16', 'Array.prototype.every')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.6.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.every', 'Array.prototype.every')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_navegadores">Compatibilidade em navegadores</h2>
+
+<div>{{Compat("javascript.builtins.Array.every")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Array.prototype.some()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.every()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/fill/index.html b/files/pt-br/web/javascript/reference/global_objects/array/fill/index.html
new file mode 100644
index 0000000000..8957bf3023
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/fill/index.html
@@ -0,0 +1,125 @@
+---
+title: Array.prototype.fill()
+slug: Web/JavaScript/Reference/Global_Objects/Array/fill
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/fill
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>fill()</strong></code> preenche todos os valores do array a partir do índice inicial a um índice final com um valor estático.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.fill(<var>valor</var>[, <var>ínicio<var> = 0[, <var>fim</var> = this.length]])</var></var></code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>valor</var></code></dt>
+ <dd>Valor para preencher o array.</dd>
+ <dt><code><var>ínicio</var></code></dt>
+ <dd>Opcional. Índice inicial.</dd>
+ <dt><code><var><var><var>fim</var></var></var></code></dt>
+ <dd>Opcional. Índice final.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O intervalo de preenchimento dos elementos é  [<code>início</code>, <code>fim</code>).</p>
+
+<p>O método <strong><code>fill</code></strong> pode receber até três argumentos <code>valor</code>, <code>ínicio</code> e <code>fim</code>. Os argumentos <code>ínicio</code> e <code>fim</code> são opcionais com valor padrão <code>0 (valor) </code>e o tamanho do objeto <code>(fim)</code>.</p>
+
+<p>Se o <code>ínicio</code> for negativo, ele será tratado como <code>tamanho + ínicio</code> onde <code>tamanho é o tamanho total do array</code>. Se o <code>fim</code> for negativo, ele será tratado como <code>tamanho + fim</code>.</p>
+
+<p>A função <strong>fill</strong> é intencionalmente genérica, ele não precisa que o valor do this seja um objeto Array.</p>
+
+<p>O método <strong>fill</strong> é um método mutável, ele irá mudar o objeto em si, e retorná-lo, não somente uma cópia do objeto.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">[1, 2, 3].fill(4);               // [4, 4, 4]
+[1, 2, 3].fill(4, 1);            // [1, 4, 4]
+[1, 2, 3].fill(4, 1, 2);         // [1, 4, 3]
+[1, 2, 3].fill(4, 1, 1);         // [1, 2, 3]
+[1, 2, 3].fill(4, -3, -2);       // [4, 2, 3]
+[1, 2, 3].fill(4, NaN, NaN);     // [1, 2, 3]
+Array(3).fill(4);                // [4, 4, 4]
+[].fill.call({ length: 3 }, 4);  // {0: 4, 1: 4, 2: 4, length: 3}
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">if (!Array.prototype.fill) {
+  Array.prototype.fill = function(value) {
+
+    // Passo 1-2.
+    if (this == null) {
+      throw new TypeError('this is null or not defined');
+    }
+
+    var O = Object(this);
+
+    // Passo 3-5.
+    var len = O.length &gt;&gt;&gt; 0;
+
+    // Passo 6-7.
+    var start = arguments[1];
+    var relativeStart = start &gt;&gt; 0;
+
+    // Passo 8.
+    var k = relativeStart &lt; 0 ?
+      Math.max(len + relativeStart, 0) :
+      Math.min(relativeStart, len);
+
+    // Passo 9-10.
+    var end = arguments[2];
+    var relativeEnd = end === undefined ?
+      len : end &gt;&gt; 0;
+
+    // Passo 11.
+    var final = relativeEnd &lt; 0 ?
+      Math.max(len + relativeEnd, 0) :
+      Math.min(relativeEnd, len);
+
+    // Passo 12.
+    while (k &lt; final) {
+      O[k] = value;
+      k++;
+    }
+
+    // Passo 13.
+    return O;
+  };
+}
+</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-array.prototype.fill', 'Array.prototype.fill')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<div>{{Compat("javascript.builtins.Array.fill")}}</div>
+
+<div id="compat-desktop"></div>
+
+<p>[1] Começando com Chrome 36, isto era disponível com uma mudança nas preferencias. Em chrome://flags, ativar a entrada “Enable Experimental JavaScript”.</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+ <li>{{jsxref("TypedArray.prototype.fill()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html b/files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html
new file mode 100644
index 0000000000..c7b0c08915
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/filtro/index.html
@@ -0,0 +1,227 @@
+---
+title: Array.prototype.filter()
+slug: Web/JavaScript/Reference/Global_Objects/Array/filtro
+tags:
+  - Array
+  - ECMAScript 5
+  - JavaScript
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/filter
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>filter()</strong></code> cria um novo array com todos os elementos que passaram no teste implementado pela função fornecida.</p>
+
+<pre class="brush: js">function isBigEnough(value) {
+  return value &gt;= 10;
+}
+
+var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+// filtrado é [12, 130, 44]
+</pre>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>var newArray = arr</var>.filter(<var>callback</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função é um predicado, para testar cada elemento do array. Retorna <code>true</code> para manter o elemento, <code>false</code> caso contrário, recebendo três argumentos:</dd>
+ <dd>
+ <dl>
+  <dt><code>element</code></dt>
+  <dd>
+  <p>O elemento que está sendo processado no array.</p>
+  </dd>
+  <dt><code>index</code></dt>
+  <dd>O índice do elemento atual que está sendo processado no array.</dd>
+  <dt><code>array</code></dt>
+  <dd>O array para qual <code>filter</code> foi chamada.</dd>
+ </dl>
+ </dd>
+ <dt><code>thisArg {{Optional_inline}}</code></dt>
+ <dd>Opcional. Valor a ser usado como <code>this</code> durante a execução do <code>callback</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um novo array com os elementos que passaram no teste.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>filter()</code> chama a função callback fornecida, uma vez para cada elemento do array, e constrói um novo array com todos os valores para os quais o <code>callback</code> retornou o valor <code>true</code> ou  <a href="/en-US/docs/Glossary/Truthy">um valor que seja convertido para true</a>. O <code>callback</code> é chamado apenas para índices do array que possuem valores atribuídos; Ele não é invocado para índices que foram excluídos ou para aqueles que não tiveram valor atribuído. Elementos do array que não passaram no teste do <code>callback</code> são simplesmente ignorados, e não são incluídos no novo array.</p>
+
+<p><code>callback</code> é invocado com estes três argumentos:</p>
+
+<ol>
+ <li>o valor do elemento</li>
+ <li>o índice do elemento</li>
+ <li>o objeto do array a ser preenchido</li>
+</ol>
+
+<p>Se o parâmetro <code>thisArg</code> for provido para o filter, ele será passado para o callback<code> quando invocado</code>, para ser usado como o valor do this. Caso contrário, será passado <code>undefined</code> como o valor de <code>this</code>. O valor do <code>this</code> finalmente observado pela função de <code>callback</code> é determinado de acordo com <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">a regra que define o valor do <code>this</code> geralmente visto por uma função</a>.</p>
+
+<p><code>filter()</code> não altera o <code>array</code> a partir da qual foi invocado.</p>
+
+<p>O intervalo de elementos processados pela função <code>filter()</code> é definido antes da invocação do primeiro callback. Elementos que forem adicionados ao array depois da invocação do <code>filter()</code> não serão visitados pelo <code>callback</code>. Se elementos existentes no array forem alterados ou deletados, os valores deles que serão passados para o callback são os que eles tiverem quando o  <code>filter()</code> visitá-los; Elementos que forem deletados não são visitados.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_Filtrando_todos_os_valores_pequenos">Exemplo: Filtrando todos os valores pequenos</h3>
+
+<p>Os exemplos a seguir usam <code>filter()</code> para criar um <code>array</code> filtrado em que todos os elementos com valores menores que 10 são removidos.</p>
+
+<pre class="brush: js">function isBigEnough(value) {
+  return value &gt;= 10;
+}
+var filtered = [12, 5, 8, 130, 44].filter(isBigEnough);
+// filtered is [12, 130, 44]
+</pre>
+
+<h3 id="Exemplo_Filtrando_entradas_inválidas_para_JSON">Exemplo: Filtrando entradas inválidas para JSON</h3>
+
+<p>O exemplo a seguir usa <code>filter()</code> para criar um <code>JSON</code> filtrado com todos seus elementos diferentes de zero, e <code>id</code> numérico.</p>
+
+<pre class="brush: js">var arr = [
+  { id: 15 },
+  { id: -1 },
+  { id: 0 },
+  { id: 3 },
+  { id: 12.2 },
+  { },
+  { id: null },
+  { id: NaN },
+  { id: 'undefined' }
+];
+
+var invalidEntries = 0;
+
+function filterByID(obj) {
+  if ('id' in obj &amp;&amp; typeof(obj.id) === 'number' &amp;&amp; !isNaN(obj.id)) {
+    return true;
+  } else {
+    invalidEntries++;
+    return false;
+  }
+}
+
+var arrByID = arr.filter(filterByID);
+
+console.log('Filtered Array\n', arrByID);
+// [{ id: 15 }, { id: -1 }, { id: 0 }, { id: 3 }, { id: 12.2 }]
+
+console.log('Number of Invalid Entries = ', invalidEntries);
+// Number of Invalid Entries = 4
+</pre>
+
+<h3 id="Procurando_em_um_array">Procurando em um array</h3>
+
+<p>O exemplo a seguir usa <code>filter()</code> para filtrar o conteúdo de um array baseado em um critério de busca</p>
+
+<pre class="brush: js">var fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
+/**
+ * Array filters items based on search criteria (query)
+ */
+function filterItems(query) {
+  return fruits.filter(function(el) {
+      return el.toLowerCase().indexOf(query.toLowerCase()) &gt; -1;
+  })
+}
+
+console.log(filterItems('ap')); // ['apple', 'grapes']
+console.log(filterItems('an')); // ['banana', 'mango', 'orange']</pre>
+
+<h3 id="Implementação_ES2015">Implementação ES2015</h3>
+
+<pre class="brush: js">const fruits = ['apple', 'banana', 'grapes', 'mango', 'orange'];
+
+/**
+ * Array filters items based on search criteria (query)
+ */
+const filterItems = (query) =&gt; {
+  return fruits.filter(el =&gt; el.toLowerCase().indexOf(query.toLowerCase()) &gt; -1);
+};
+
+console.log(filterItems('ap')); // ['apple', 'grapes']
+console.log(filterItems('an')); // ['banana', 'mango', 'orange']</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p><code>filter()</code> foi adicionado ao padrão ECMA-262 na 5ª edição; assim como pode não estar presente em todas as implementações do padrão. Você pode trabalhar com isso adicionando o seguinte código no início de seus scripts, permitindo o uso do <code>filter()</code> na implementação ECMA-262 que não tem suporte nativo. Esse algoritmo é exatamente aquele especificado na 5ª edição do ECMA-262, assumindo que <code>fn.call</code> veja o valor original de {{jsxref("Function.prototype.call()")}}, e que {{jsxref("Array.prototype.push()")}} tenha seu valor original.</p>
+
+<pre class="brush: js">if (!Array.prototype.filter) {
+  Array.prototype.filter = function(fun/*, thisArg*/) {
+    'use strict';
+
+    if (this === void 0 || this === null) {
+      throw new TypeError();
+    }
+
+    var t = Object(this);
+    var len = t.length &gt;&gt;&gt; 0;
+    if (typeof fun !== 'function') {
+      throw new TypeError();
+    }
+
+    var res = [];
+    var thisArg = arguments.length &gt;= 2 ? arguments[1] : void 0;
+    for (var i = 0; i &lt; len; i++) {
+      if (i in t) {
+        var val = t[i];
+
+        // NOTE: Technically this should Object.defineProperty at
+        //       the next index, as push can be affected by
+        //       properties on Object.prototype and Array.prototype.
+        //       But that method's new, and collisions should be
+        //       rare, so use the more-compatible alternative.
+        if (fun.call(thisArg, val, i, t)) {
+          res.push(val);
+        }
+      }
+    }
+
+    return res;
+  };
+}
+</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('ES5.1', '#sec-15.4.4.20', 'Array.prototype.filter')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.6.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.filter', 'Array.prototype.filter')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<div>{{Compat("javascript.builtins.Array.filter")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+ <li>{{jsxref("Array.prototype.some()")}}</li>
+ <li>{{jsxref("Array.prototype.reduce()")}}</li>
+</ul>
+
+<div id="link64_adl_tabid" style="display: none;">24</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/find/index.html b/files/pt-br/web/javascript/reference/global_objects/array/find/index.html
new file mode 100644
index 0000000000..904f65c200
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/find/index.html
@@ -0,0 +1,157 @@
+---
+title: Array.prototype.find()
+slug: Web/JavaScript/Reference/Global_Objects/Array/find
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/find
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>find()</strong></code> retorna o <strong>valor </strong>do <strong>primeiro elemento</strong> do array que satisfizer a função de teste provida. Caso contrario, {{jsxref("undefined")}} é retornado.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/array-find.html")}}</div>
+
+<p class="hidden">O código-fonte desse exemplo interativo está em um repositório do GitHub. Se você quiser contribuir para o projeto de exemplos interativos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p>
+
+<p>Veja também o método {{jsxref("Array.findIndex", "findIndex()")}}, que retorna o <strong>índice</strong> do elemento encontrado no array ao invés do seu valor.</p>
+
+<p>Se você precisa encontrar a posição de um elemento ou se um elemento existe em um array, use {{jsxref("Array.prototype.indexOf()")}} ou {{jsxref("Array.prototype.includes()")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>arr</var>.find(<var>callback(element[, index[, array]])</var>[, <var>thisArg</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função executada a cada iteração do array, recebendo três argumentos:
+ <dl>
+  <dt><code>element</code></dt>
+  <dd>O elemento atual que está sendo processado no array.</dd>
+  <dt><code>index</code>{{optional_inline}}</dt>
+  <dd>O índice do elemento atualmente sendo processado no array.</dd>
+  <dt><code>array</code>{{optional_inline}}</dt>
+  <dd>O array sobre o qual <code>find</code> foi chamado.</dd>
+ </dl>
+ </dd>
+ <dt><code>thisArg</code>{{optional_inline}}</dt>
+ <dd>Opcional. Objeto usado como <code>this</code> quando executando o <code>callback</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O <strong>valor</strong> do <strong>primeiro elemento</strong> do array que satisfaz a função de teste fornecida; caso contrário, {{jsxref("undefined")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>find</code> executa a função <code>callback </code>uma vez para cada elemento presente no array até que encontre um onde <code>callback</code>  retorne o valor true. Se o elemento é encontrado, <code>find</code> retorna imediatamente o valor deste elemento. Caso contrário, <code>find</code> retorna {{jsxref("Global_Objects/undefined", "undefined")}}. O <code>callback </code>é acionado para todos os índices do array de <code>0</code> a <code>tamanho-1</code>, não apenas para aqueles que possuem valores atribuídos. Sendo assim, ele pode ser menos eficiente para arrays muito grandes em que existem outros métodos que só visitam os índices que tenham valor atribuído.</p>
+
+<p>O <code>callback</code> é acionado com três argumentos: o valor do elemento, o índice do elemento e o objeto do Array que está sendo executado.</p>
+
+<p>Se um parâmetro <code>thisArg</code> é provido ao <code>find</code>, ele será usado como o <code>this</code> para cada acionamento do <code>callback</code>. Se não for provido, então {{jsxref("Global_Objects/undefined", "undefined")}} é usado.</p>
+
+<p>O <code>find</code> não altera a array à qual foi acionado.</p>
+
+<p>O conjunto dos elementos processados por <code>find</code> é definido antes do primeiro acionamento do <code>callback</code>. Elementos que são anexados à array após o início da chamada ao <code>find</code> não serão visitados pelo <code>callback</code>. Se um elemento existente ainda não visitado da array for alterado pelo <code>callback</code>, o valor passado ao <code>callback</code> quando o visitar será o valor no momento que <code>find</code> visita o índice daquele elemento; elementos excluídos ainda são visitados.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Encontrar_um_objeto_em_um_array_por_uma_de_suas_propriedades">Encontrar um objeto em um array por uma de suas propriedades</h3>
+
+<pre class="brush: js notranslate">const inventory = [
+    {name: 'apples', quantity: 2},
+    {name: 'bananas', quantity: 0},
+    {name: 'cerejas', quantity: 5}
+];
+
+function isCherries(fruit) {
+    return fruit.name === 'cerejas';
+}
+
+console.log(inventory.find(isCherries));
+// { name: 'cerejas', quantity: 5 }</pre>
+
+<h4 id="Utilizando_arrow_function">Utilizando arrow function</h4>
+
+<pre class="brush: js notranslate">const inventory = [
+    {name: 'maças', quantity: 2},
+    {name: 'bananas', quantity: 0},
+    {name: 'cherries', quantity: 5}
+];
+
+const result = inventory.find( fruit =&gt; fruit.name === 'cherries' );
+
+console.log(result) // { name: 'cherries', quantity: 5 }</pre>
+
+<h3 id="Encontrar_um_número_primo_em_um_array">Encontrar um número primo em um array</h3>
+
+<p>O exemplo a seguir encontra um elemento dentro da array que é número primo (ou retorna {{jsxref("Global_Objects/undefined", "undefined")}} se não houverem números primos).</p>
+
+<pre class="brush: js notranslate">function isPrime(element, index, array) {
+  var start = 2;
+  while (start &lt;= Math.sqrt(element)) {
+    if (element % start++ &lt; 1) {
+      return false;
+    }
+  }
+  return element &gt; 1;
+}
+
+console.log([4, 6, 8, 12].find(isPrime)); // undefined, not found
+console.log([4, 5, 8, 12].find(isPrime)); // 5
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Este método foi adicionado à especificação do ECMAScript 2015 e pode não estar disponível em todas as implementações do JavaScript. Entretanto, você pode fazer um polyfill para o <code>Array.prototype.find</code> com o trecho de código abaixo:</p>
+
+<pre class="brush: js notranslate">if (!Array.prototype.find) {
+  Array.prototype.find = function(predicate) {
+    if (this === null) {
+      throw new TypeError('Array.prototype.find called on null or undefined');
+    }
+    if (typeof predicate !== 'function') {
+      throw new TypeError('predicate must be a function');
+    }
+    var list = Object(this);
+    var length = list.length &gt;&gt;&gt; 0;
+    var thisArg = arguments[1];
+    var value;
+
+    for (var i = 0; i &lt; length; i++) {
+      value = list[i];
+      if (predicate.call(thisArg, value, i, list)) {
+        return value;
+      }
+    }
+    return undefined;
+  };
+}
+</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-array.prototype.find', 'Array.prototype.find')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_Navegador">Compatibilidade do Navegador</h2>
+
+<div>{{Compat("javascript.builtins.Array.find")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html b/files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html
new file mode 100644
index 0000000000..75c677d20d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/findindex/index.html
@@ -0,0 +1,127 @@
+---
+title: Array.prototype.findIndex()
+slug: Web/JavaScript/Reference/Global_Objects/Array/findIndex
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/findIndex
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>findIndex()</strong></code> retorna o <strong>índice</strong> no array do primeiro elemento que satisfizer a função de teste provida. Caso contrário, retorna -1, indicando que nenhum elemento passou no teste.</p>
+
+<p>Veja também o método {{jsxref("Array.find", "find()")}}, que retorna o <strong>valor</strong> de um elemento encontrado no array em vez de seu índice.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.findIndex(<var>callback</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função para executar em cada valor no array, tomando três argumentos:
+ <dl>
+  <dt><code>element</code></dt>
+  <dd>O elemento atual sendo processado no array.</dd>
+  <dt><code>index</code></dt>
+  <dd>O índice do elemento atual sendo processado no array.</dd>
+  <dt><code>array</code></dt>
+  <dd>O array sobre o qual <code>findIndex</code> foi chamado.</dd>
+ </dl>
+ </dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Opcional. Objeto para usar como <code>this</code> na execução do <code>callback</code>.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>findIndex</code> executa a função <code>callback</code> uma vez para cada elemento presente no array até encontrar um onde o <code>callback</code> retorna um valor verdadeiro. Se tal elemento for encontrado, <code>findIndex</code> imediatamente retorna o índice deste elemento. Caso contrário, <code>findIndex</code> retorna -1. <code>callback</code> é invocado apenas para índices no array que têm valores atribuídos; nunca é invocado para índices que foram deletados ou que nunca tiveram valores atribuídos.</p>
+
+<p><code>callback</code> é invocado com três argumentos: o valor do elemento, o índice do elemento e o objeto Array sendo percorrido.</p>
+
+<p>Se um parâmetro <code>thisArg</code> for fornecido para <code>findIndex</code>, ele será usado como o <code>this</code> para cada invocação do <code>callback</code>. Se não for fornecido, então {{jsxref("undefined")}} é usado.</p>
+
+<p><code>findIndex</code> não modifica o array sobre o qual é chamado.</p>
+
+<p>A série de elementos processados por <code>findIndex</code> é definida antes da primeira invocação do <code>callback</code>. Elementos que são adicionados ao array depois que a chamada a <code>findIndex</code> começa não serão visitados pelo <code>callback</code>. Se um elemento existente não visitado do array for modificado pelo <code>callback</code>, seu valor passado ao <code>callback</code> será o valor no momento em que <code>findIndex</code> visitar o índice deste elemento; elementos que forem deletados não são visitados.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Encontrar_o_índice_de_um_número_primo_em_um_array">Encontrar o índice de um número primo em um array</h3>
+
+<p>O seguinte exemplo encontra o índice de um elemento no array que é um número primo (ou retorna -1 se não houver número primo).</p>
+
+<pre class="brush: js notranslate">function isPrime(element, index, array) {
+  var start = 2;
+  while (start &lt;= Math.sqrt(element)) {
+    if (element % start++ &lt; 1) {
+      return false;
+    }
+  }
+  return element &gt; 1;
+}
+
+console.log([4, 6, 8, 12].findIndex(isPrime)); // -1, não encontrado
+console.log([4, 6, 7, 12].findIndex(isPrime)); // 2
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Esse método foi adicionado à especificação do ECMAScript 6 e pode não estar disponível em todas as implementações de JavaScript ainda. Contudo, você pode fazer o polyfill de <code>Array.prototype.findIndex</code> com o seguinte trecho de código:</p>
+
+<pre class="brush: js notranslate">if (!Array.prototype.findIndex) {
+  Array.prototype.findIndex = function(predicate) {
+    if (this === null) {
+      throw new TypeError('Array.prototype.findIndex called on null or undefined');
+    }
+    if (typeof predicate !== 'function') {
+      throw new TypeError('predicate must be a function');
+    }
+    var list = Object(this);
+    var length = list.length &gt;&gt;&gt; 0;
+    var thisArg = arguments[1];
+    var value;
+
+    for (var i = 0; i &lt; length; i++) {
+      value = list[i];
+      if (predicate.call(thisArg, value, i, list)) {
+        return i;
+      }
+    }
+    return -1;
+  };
+}
+</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-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.findIndex', 'Array.prototype.findIndex')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{Compat("javascript.builtins.Array.findIndex")}}</div>
+
+<div></div>
+
+<div><span style="">Veja também</span></div>
+
+<ul>
+ <li>{{jsxref("Array.prototype.find()")}}</li>
+ <li>{{jsxref("Array.prototype.indexOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/flat/index.html b/files/pt-br/web/javascript/reference/global_objects/array/flat/index.html
new file mode 100644
index 0000000000..b14ffb006f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/flat/index.html
@@ -0,0 +1,121 @@
+---
+title: Array.prototype.flat()
+slug: Web/JavaScript/Reference/Global_Objects/Array/flat
+tags:
+  - Array
+  - Experimental
+  - JavaScript
+  - Method
+  - Prototype
+  - flat
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/flat
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>O método <code><strong>flat()</strong></code> cria um novo array com todos elementos sub-arrays concatenados nele de forma recursiva até a profundidade<em> </em>especificada.</p>
+
+<p class="hidden">\{{EmbedInteractiveExample("pages/js/array-flatten.html")}}</p>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>var novoArray = arr</var>.flat(<var>depth</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>depth</code> {{optional_inline}}</dt>
+ <dd>O nível de profundidade especifíca o quanto um array aninhando deve ser achatado. O Default é 1.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um novo array com os elementos sub-array concatenados nele.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Achatando_arrays_aninhados">Achatando arrays aninhados</h3>
+
+<pre class="brush: js notranslate">var arr1 = [1, 2, [3, 4]];
+arr1.flat();
+// [1, 2, 3, 4]
+
+var arr2 = [1, 2, [3, 4, [5, 6]]];
+arr2.flat();
+// [1, 2, 3, 4, [5, 6]]
+
+var arr3 = [1, 2, [3, 4, [5, 6]]];
+arr3.flat(2);
+// [1, 2, 3, 4, 5, 6]
+
+<code>const arr4 = [1, 2, [3, 4, [5, 6, [7, 8]]]];
+arr4.flat(Infinity);
+// [1, 2, 3, 4, 5, 6, 7, 8]</code></pre>
+
+<h3 id="Achatando_e_buracos_em_array">Achatando e buracos em array</h3>
+
+<p>o método flat remove espaços vazios do array:</p>
+
+<pre class="brush: js notranslate">var arr4 = [1, 2, , 4, 5];
+arr4.flat();
+// [1, 2, 4, 5]</pre>
+
+<div class="line"></div>
+
+<h2 id="Alternativa">Alternativa</h2>
+
+<h3 id="reduce_e_concat"><code>reduce</code> e <code>concat</code></h3>
+
+<pre class="brush: js notranslate">var arr1 = [1, 2, [3, 4]];
+arr1.flat();
+
+//achatar array de nível único
+arr1.reduce((acc, val) =&gt; acc.concat(val), []);
+// [1, 2, 3, 4]
+
+//para achatamentos mais profundos, use recursividade com reduce e concat
+var arr1 = [1,2,3,[1,2,3,4, [2,3,4]]];
+
+(function flattenDeep(arr1){
+   return arr1.reduce((acc, val) =&gt; Array.isArray(val) ? acc.concat(flattenDeep(val)) : acc.concat(val), []);
+})(arr1);
+
+// [1, 2, 3, 1, 2, 3, 4, 2, 3, 4]
+
+
+</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ários</th>
+  </tr>
+  <tr>
+   <td><a href="https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flat"><code>Array.prototype.flat</code> proposal</a></td>
+   <td>Draft</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_Navegadores">Compatibilidade em Navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Array.flat")}}</p>
+</div>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.flatMap()")}}</li>
+ <li>{{jsxref("Array.prototype.map()")}}</li>
+ <li>{{jsxref("Array.prototype.reduce()")}}</li>
+ <li>{{jsxref("Array.prototype.concat()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/flatmap/index.html b/files/pt-br/web/javascript/reference/global_objects/array/flatmap/index.html
new file mode 100644
index 0000000000..f75edaf3ef
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/flatmap/index.html
@@ -0,0 +1,126 @@
+---
+title: Array.prototype.flatMap()
+slug: Web/JavaScript/Reference/Global_Objects/Array/flatMap
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/flatMap
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>O método <strong><code>flatMap()</code></strong> primeiro mapeia cada elemento usando uma função de mapeamento e, em seguida, nivela o resultado em um novo array. É idêntico a um <code>map</code> seguido por um <code>flat</code> de profundidade 1, mas <strong><code>flatMap</code></strong> é bastante útil e mescla ambos em um método um pouco mais eficiente.\{{EmbedInteractiveExample("pages/js/array-flatmap.html")}}</p>
+
+<p class="hidden">A fonte deste exemplo interativo é armazenada em um repositório GitHub. Se você quiser contribuir com o projeto de exemplos interativos, clone https://github.com/mdn/interactive-examples e envie-nos um PR</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>var new_array = arr</var>.flatMap(function <var>callback(currentValue[, index[, array]]) {
+    // retorna o elemento para new_array
+}</var>[, <var>thisArg</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função que produz um elemento de uma nova Array, pegando três argumentos:
+ <dl>
+  <dt></dt>
+  <dt><code>currentValue</code></dt>
+  <dd>O valor atual sendo processo na array.</dd>
+  <dt><code>index</code>{{optional_inline}}</dt>
+  <dd>O index do valor atual sendo processo na array.</dd>
+  <dt><code>array</code>{{optional_inline}}</dt>
+ </dl>
+
+ <p>O <code>map</code> da array que foi chamado.</p>
+ </dd>
+ <dt><code>thisArg</code>{{optional_inline}}</dt>
+ <dd>Valor para ser usado como <code>this</code> quando <code>callback</code> estiver sendo executado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma nova array com cada elemento sendo o resultado da função callback e achatado ao valor de 1.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Veja {{jsxref("Array.prototype.map()")}} para uma detalhada descrição da função callback. O método <code>flatMap</code> é idêntico ao <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map">map</a></code> seguido por um chamado a <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/flatten">flatten</a></code> de profundidade 1.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="map_e_flatMap"><code>map</code> e <code>flatMap</code></h3>
+
+<pre class="brush: js">var arr1 = <span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>[</span></span><span class="constant decimal js numeric"><span>1</span></span><span class="comma delimiter js meta object"><span>,</span></span><span> </span><span class="brace js meta square"><span>2, 3, 4];
+
+arr1.map(</span></span></span></span></span>x =&gt; [x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>);</span></span></span></span></span>
+// [[2], [4], [6], [8]]
+
+arr1.flatMap(x =&gt; [x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>);
+// [2, 4, 6, 8]</span></span></span></span></span>
+
+//  Só o primeiro nível
+arr1.flatMap(x =&gt; [[x * 2]]);
+// [[2], [4], [6], [8]]
+</pre>
+
+<p>Enquanto que acima poderíamos alcançar apenas com a utilização de map, já aqui temos um exemplo onde <code>flatMap</code> é mais apropriado.</p>
+
+<p>Vamos gerar uma lista de palavras a partir de uma lista de sentenças.</p>
+
+<pre class="brush: js">let arr1 = ["it's Sunny in", "", "California"];
+
+arr1.map(x=&gt;x.split(" "));
+// [["it's","Sunny","in"],[""],["California"]]
+
+arr1.flatMap(x =&gt; x.split(" ")<span class="js source"><span class="function-call js meta"><span class="br brace js meta square"><span>);
+// ["it's","Sunny","in", "", "California"]</span></span></span></span>
+</pre>
+
+<p>Perceba, o comprimento da lista de saída pode ser diferente do comprimento da lista de entrada.</p>
+
+<div class="line"><span class="js source"><span class="comment double-slash js line"><span class="comment definition js punctuation"><span>//</span></span><span>=&gt; [1, 2, 3, 4, 5, 6, 7, 8, 9]</span></span></span></div>
+
+<h2 id="Alternativa">Alternativa</h2>
+
+<h3 id="reduce_e_concat"><code>reduce</code> e <code>concat</code></h3>
+
+<pre class="brush: js">var arr1 = <span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>[</span></span><span class="constant decimal js numeric"><span>1</span></span><span class="comma delimiter js meta object"><span>,</span></span><span> </span><span class="brace js meta square"><span>2, 3, 4];
+</span></span></span></span></span>
+arr1.flatMap(x =&gt; [x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>);</span></span></span></span></span>
+// é equivalente a
+arr1.reduce((acc, x) =&gt; acc.concat([x * 2]<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>), []);</span></span></span></span></span>
+<span class="js source"><span class="function-call js meta"><span class="js meta"><span class="brace js meta square"><span>// [2, 4, 6, 8]</span></span></span></span></span>
+</pre>
+
+<div class="line"><span class="js source"><span class="comment double-slash js line"><span class="comment definition js punctuation"><span>//</span></span><span>=&gt; [1, 2, 3, 4, 5, 6, 7, 8, 9]</span></span></span></div>
+
+<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><a href="https://tc39.github.io/proposal-flatMap/#sec-Array.prototype.flatMap"><code>Array.prototype.flatMap</code> proposal</a></td>
+   <td>Rascunho</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browser">Compatibilidade de browser</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, confira https://github.com/mdn/browser-compat-data e envie-nos uma PR</div>
+
+<p>{{Compat("javascript.builtins.Array.flatMap")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.flatten()")}}</li>
+ <li>{{jsxref("Array.prototype.map()")}}</li>
+ <li>{{jsxref("Array.prototype.reduce()")}}</li>
+ <li>{{jsxref("Array.prototype.concat()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html b/files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html
new file mode 100644
index 0000000000..3ff4e43901
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/foreach/index.html
@@ -0,0 +1,212 @@
+---
+title: Array.prototype.forEach()
+slug: Web/JavaScript/Reference/Global_Objects/Array/forEach
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>forEach()</code> executa uma dada função em cada elemento de um array.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>arr</var>.forEach(<var>callback(currentValue [, index [, array]])</var>[, <var>thisArg</var>]);</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função para executar em cada elemento, recebendo três argumentos:
+ <dl>
+  <dt><code>currentValue</code></dt>
+  <dd>O valor atual do elemento sendo processado no array.</dd>
+  <dt><code>index</code> {{optional_inline}}</dt>
+  <dd>O índice do elemento atual sendo processado no array.</dd>
+  <dt><code>array</code> {{optional_inline}}</dt>
+  <dd>O array que <code>forEach()</code> está sendo aplicado.</dd>
+ </dl>
+ </dd>
+ <dt><code>thisArg</code> {{optional_inline}}</dt>
+ <dd>Opcional. Valor a ser usado como <code>this</code> quando executar <code>callback</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p><code>undefined</code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>forEach</code> executa o <code>callback</code> fornecido uma vez para cada elemento da ordem com um valor atribuido. Ele não é invocado para propriedades de índices que foram deletados ou que não foram inicializados (por ex. em arrays esparsos).</p>
+
+<p><code>callback</code> é invocado com <strong>três argumentos</strong>:</p>
+
+<ul>
+ <li>o <strong>valor do elemento</strong></li>
+ <li>o <strong>índice do elemento</strong></li>
+ <li>o <strong>array que está sendo percorrido</strong></li>
+</ul>
+
+<p>Se um parâmetro <code>thisArg</code> for passado para <code>forEach()</code>, ele será passado para o <code>callback</code>  quando invocado como valor para <code>this</code>.  Caso contrário, o valor {{jsxref("undefined")}} será passado como valor para <code>this</code>. O valor de <code>this</code> assumido no <code>callback</code> é determinado de acordo com as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this">regras usuais para determinação do <code>this</code> visto por uma função</a>.</p>
+
+<p>O intervalo dos elementos processados por <code>forEach()</code> é determinado antes da primeira invocação do <code>callback</code>. Elementos que forem adicionados ao array depois da chamada ao <code>forEach()</code> começar não serão visitados pelo <code>callback</code>. Se os valores dos elementos existentes do array forem alterados, o valor passado para o <code>callback</code> será o valor no momento em que o <code>forEach()</code> visitá-los; elementos que forem deletados antes de serem visitados não serão visitados.</p>
+
+<p><code>forEach()</code> executa a a função <code>callback</code> uma vez para cada elemento do array – diferentemente de {{jsxref("Array.prototype.map()", "map()")}} ou {{jsxref("Array.prototype.reduce()", "reduce()")}}, ele sempre retorna o valor {{jsxref("undefined")}} e não é encadeável. O caso de uso típico é alterar o array no final do loop.</p>
+
+<div class="note">
+<p>A única maneira de parar ou interromper um loop <code>forEach()</code> é disparando uma exceção. Se você precisa desse recurso, o método <code>forEach()</code> é a ferramenta errada. Você estará mais bem servido com um loop simples nesse caso. Se estiver testando o array de elementos para um predicado e precisar de um valor de retorno Boleano, você pode usar {{jsxref("Array.prototype.every()", "every()")}} ou {{jsxref("Array.prototype.some()", "some()")}}. Se estiverem disponíveis, os novos métodos {{jsxref("Array.prototype.find()", "find()")}} e {{jsxref("Array.prototype.findIndex()", "findIndex()")}} também podem ser usados para terminação antecipada em predicados verdadeiros.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Imprimindo_os_conteúdos_de_uma_ordem">Imprimindo os conteúdos de uma ordem</h3>
+
+<p>Os códigos a seguir logam uma linha para cada elemento na ordem:</p>
+
+<pre class="brush:js">function logArrayElements(element, index, array) {
+    console.log("a[" + index + "] = " + element);
+}
+[2, 5, 9].forEach(logArrayElements);
+// logs:
+// a[0] = 2
+// a[1] = 5
+// a[2] = 9
+</pre>
+
+<h3 id="Função_para_cópia_de_um_objeto">Função para cópia de um objeto</h3>
+
+<p>O código a seguir cria uma cópia para cada objeto dado. Há diferentes formas de criar uma cópia para um objeto. Esta é somente uma forma de explicar como  <code>Array.prototype.forEach</code> funciona. Ela usa um grupo de novas funções ECMAScript 5 Object.*</p>
+
+<pre class="brush: js">function copy(o){
+  var copy = Object.create( Object.getPrototypeOf(o) );
+  var propNames = Object.getOwnPropertyNames(o);
+
+  propNames.forEach(function(name){
+    var desc = Object.getOwnPropertyDescriptor(o, name);
+    Object.defineProperty(copy, name, desc);
+  });
+
+  return copy;
+}
+
+var o1 = {a:1, b:2};
+var o2 = copy(o1); // o2 looks like o1 now
+</pre>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<p><code>forEach</code> é uma adição recente para o ECMA-262 standard; assim sendo, pode não estar presente em outras implementações do standard. Você pode contornar isto pela inserção do código a seguir no começo de seus scripts, permitindo o uso de <code>forEach</code> em implementações que normalmente não possuem este suporte.</p>
+
+<pre class="brush:js">if ( !Array.prototype.forEach ) {
+  Array.prototype.forEach = function(fn, scope) {
+    for(var i = 0, len = this.length; i &lt; len; ++i) {
+      fn.call(scope, this[i], i, this);
+    }
+  };
+}
+</pre>
+
+<p>Um algorítimo 100% verdadeiro para a 5ª Edição do ECMA-262, pode ser visto abaixo:</p>
+
+<p>O algoritmo é exatamente o especificado na 5ª Edição da  ECMA-262, assumindo <code>Object</code> e<code> TypeError</code> possuem seus valores originais e avalia <code>callback.call</code> para o valor original de <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Function/call" title="JavaScript/Reference/Global Objects/Function/call">Function.prototype.call</a></code>.</p>
+
+<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.18
+// Reference: http://es5.github.com/#x15.4.4.18
+if ( !Array.prototype.forEach ) {
+
+  Array.prototype.forEach = function forEach( callback, thisArg ) {
+
+    var T, k;
+
+    if ( this == null ) {
+      throw new TypeError( "this is null or not defined" );
+    }
+
+    // 1. Let O be the result of calling ToObject passing the |this| value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length &gt;&gt;&gt; 0; // Hack to convert O.length to a UInt32
+
+    // 4. If IsCallable(callback) is false, throw a TypeError exception.
+    // See: http://es5.github.com/#x9.11
+    if ( {}.toString.call(callback) !== "[object Function]" ) {
+      throw new TypeError( callback + " is not a function" );
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if ( thisArg ) {
+      T = thisArg;
+    }
+
+    // 6. Let k be 0
+    k = 0;
+
+    // 7. Repeat, while k &lt; len
+    while( k &lt; len ) {
+
+      var kValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if ( Object.prototype.hasOwnProperty.call(O, k) ) {
+
+        // i. Let kValue be the result of calling the Get internal method of O with argument Pk.
+        kValue = O[ k ];
+
+        // ii. Call the Call internal method of callback with T as the this value and
+        // argument list containing kValue, k, and O.
+        callback.call( T, kValue, k, O );
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+    // 8. return undefined
+  };
+}
+</pre>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<p>{{Compat("javascript.builtins.Array.forEach")}}</p>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table>
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.18', 'Array.prototype.forEach')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.6.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.find()")}}</li>
+ <li>{{jsxref("Array.prototype.findIndex()")}}</li>
+ <li>{{jsxref("Array.prototype.map()")}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+ <li>{{jsxref("Array.prototype.some()")}}</li>
+ <li>{{jsxref("Map.prototype.forEach()")}}</li>
+ <li>{{jsxref("Set.prototype.forEach()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/from/index.html b/files/pt-br/web/javascript/reference/global_objects/array/from/index.html
new file mode 100644
index 0000000000..798f1c727d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/from/index.html
@@ -0,0 +1,205 @@
+---
+title: Array.from()
+slug: Web/JavaScript/Reference/Global_Objects/Array/from
+tags:
+  - Array
+  - ECMAScript 2015
+  - ES6
+  - Method
+  - Reference
+  - polyfill
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/from
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <code><strong>Array.from()</strong></code> cria uma nova instância <code>de um Array</code> quando for passado um array-like ou um iterable object como argumento.</p>
+
+<p>No  ES6, <span id="result_box" lang="pt"><span class="hps">a sintaxe</span> <span class="hps">de classe</span> permite a<span class="hps"> subclassificação de </span>classes nativas e classes <span class="hps">definidas pelo usuário; como </span><span class="hps">resultado</span><span>, os métodos estáticos</span> <span class="hps">pertencentes a classe,</span> <span class="hps">como</span> </span> <code><strong>Array.from,</strong></code><span lang="pt"> <span class="hps">são</span> <span class="atn hps">"</span><span>herdadas</span><span>"</span> por <span class="hps">subclasses</span> <span class="hps">do </span></span><code><strong>Array</strong></code><span lang="pt"> <span class="hps">e criam </span><span class="hps">novas instâncias da</span> <span class="hps">subclasse,</span> <span class="hps">não</span> <span class="hps">do </span></span><code><strong>Array</strong></code><span lang="pt"><span class="hps">.</span></span></p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>Array.from(arrayLike[, mapFn[, thisArg]])
+</code></pre>
+
+<h3 id="Parameters" name="Parameters"><span>Parâmetros</span></h3>
+
+<dl>
+ <dt><code>arrayLike</code></dt>
+ <dd>Um array-like ou um objeto iterável para converter em array.</dd>
+ <dt><code>mapFn</code></dt>
+ <dd><em>Opcional</em>. Função Map que será chamada para cada elemento do array.</dd>
+ <dt><code>thisArg</code></dt>
+ <dd><em>Opcional</em>. Valor a ser utilizado como this quando a mapFn for chamada.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><code>Array.from()</code> deixa você criar um Array de:</p>
+
+<ul>
+ <li>objetos array-like (objetos com a propriedade <code>length</code> e elementos indexados); ou</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/iterable">Objetos iteráveis</a> (objetos onde você pode coletar seus elementos, assim como {{jsxref("Map")}} e {{jsxref("Set")}}).</li>
+</ul>
+
+<p><code>Array.from()</code> tem um parametro opcional <code>mapFn</code>, que permite executar a função {{jsxref("Array.prototype.map", "map")}} para cada elemento do array (ou subclasse de objeto) que está sendo criado. Simplificando,<code> Array.from(obj, mapFn, thisArg)</code> é o mesmo que <code>Array.from(obj).map(mapFn, thisArg)</code>, com a excessão de não cria um array intermediário . Isso é importante, principalmente para certas subclasses de array, como <a href="/en-US/docs/Web/JavaScript/Typed_arrays">typed array</a>, no qual o array intermediário iria necessáriamente ter o valor truncado para encaixar-se no tipo apropriado.</p>
+
+<p>A propriedade <code>length</code> do método <code>from()</code> é <code>1</code>.</p>
+
+<p>No ES2015, a sintaxe de class permite a definição de subclasses tanto internas quando definidas pelo usuário. Como resultado, métodos estáticos como <code>Array.from()</code> são "herdados" pelas subclasses de <code>Array</code>, e cria novas instâncias da subclasse, não de <code>Array</code>.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p><code>Array.from</code> foi adicionado ao padrão ECMA-262 em sua 6ª edição; desta forma, <span id="result_box" lang="pt"><span class="hps">não</span> <span class="hps">está presente</span> <span class="hps">na</span> <span class="hps">aplicações anteriores da especificação</span></span>. Na ausência do código nativo, você pode inserir o código seguinte no início do script, permitindo <code>o uso parcial da funcionalidade do Array.from</code>.  Esse algorítmo  é equivalente ao especificado no ECMA-262, 6ª edição, exceto que <code>Object</code> e <code>TypeError</code> tem seus valores originais e que <code>callback.call</code> retorna o valor original de {{jsxref("Function.prototype.call")}}. Além disso, <span id="result_box" lang="pt"><span class="hps">os verdadeiros</span> <span class="hps">iterables</span> <span class="hps">não</span> podem ser representados</span> genéricamente no polyfill, criando a principal distinção do que foi definido na especificação.</p>
+
+<pre class="brush: js notranslate">// Production steps of ECMA-262, Edition 6, 22.1.2.1
+// Reference: https://people.mozilla.org/~jorendorff/es6-draft.html#sec-array.from
+if (!Array.from) {
+  Array.from = (function () {
+    var toStr = Object.prototype.toString;
+    var isCallable = function (fn) {
+      return typeof fn === 'function' || toStr.call(fn) === '[object Function]';
+    };
+    var toInteger = function (value) {
+      var number = Number(value);
+      if (isNaN(number)) { return 0; }
+      if (number === 0 || !isFinite(number)) { return number; }
+      return (number &gt; 0 ? 1 : -1) * Math.floor(Math.abs(number));
+    };
+    var maxSafeInteger = Math.pow(2, 53) - 1;
+    var toLength = function (value) {
+      var len = toInteger(value);
+      return Math.min(Math.max(len, 0), maxSafeInteger);
+    };
+
+    // The length property of the from method is 1.
+    return function from(arrayLike/*, mapFn, thisArg */) {
+      // 1. Let C be the this value.
+      var C = this;
+
+      // 2. Let items be ToObject(arrayLike).
+      var items = Object(arrayLike);
+
+      // 3. ReturnIfAbrupt(items).
+      if (arrayLike == null) {
+        throw new TypeError("Array.from requires an array-like object - not null or undefined");
+      }
+
+      // 4. If mapfn is undefined, then let mapping be false.
+      var mapFn = arguments.length &gt; 1 ? arguments[1] : void undefined;
+      var T;
+      if (typeof mapFn !== 'undefined') {
+        // 5. else
+        // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
+        if (!isCallable(mapFn)) {
+          throw new TypeError('Array.from: when provided, the second argument must be a function');
+        }
+
+        // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
+        if (arguments.length &gt; 2) {
+          T = arguments[2];
+        }
+      }
+
+      // 10. Let lenValue be Get(items, "length").
+      // 11. Let len be ToLength(lenValue).
+      var len = toLength(items.length);
+
+      // 13. If IsConstructor(C) is true, then
+      // 13. a. Let A be the result of calling the [[Construct]] internal method of C with an argument list containing the single item len.
+      // 14. a. Else, Let A be ArrayCreate(len).
+      var A = isCallable(C) ? Object(new C(len)) : new Array(len);
+
+      // 16. Let k be 0.
+      var k = 0;
+      // 17. Repeat, while k &lt; len… (also steps a - h)
+      var kValue;
+      while (k &lt; len) {
+        kValue = items[k];
+        if (mapFn) {
+          A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k);
+        } else {
+          A[k] = kValue;
+        }
+        k += 1;
+      }
+      // 18. Let putStatus be Put(A, "length", len, true).
+      A.length = len;
+      // 20. Return A.
+      return A;
+    };
+  }());
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js notranslate">// Array-like object (arguments) para um Array
+function f() {
+  return Array.from(arguments);
+}
+
+f(1, 2, 3);
+// [1, 2, 3]
+
+
+// Qualquer iterable object ...
+// com Set
+var s = new Set(["foo", window]);
+Array.from(s);
+// ["foo", window]
+
+
+// Map
+var m = new Map([[1, 2], [2, 4], [4, 8]]);
+Array.from(m);
+// [[1, 2], [2, 4], [4, 8]]
+
+
+// String
+Array.from("foo");
+// ["f", "o", "o"]
+
+
+// Usando um arrow function como função map para
+// manipular os elementos
+Array.from([1, 2, 3], x =&gt; x + x);
+// [2, 4, 6]
+
+
+// Gerando uma sequência de números
+Array.from({length: 5}, (v, k) =&gt; k);
+// [0, 1, 2, 3, 4]
+</pre>
+
+<h2 id="Especificação">Especificação</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>{{SpecName('ES6', '#sec-array.from', 'Array.from')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="compatibilidade_com_navegadores">compatibilidade com navegadores</h2>
+
+<div>
+<p>{{Compat("javascript.builtins.Array.from")}}</p>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+ <li>{{jsxref("Array.prototype.map()")}}</li>
+ <li>{{jsxref("TypedArray.from()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/index.html b/files/pt-br/web/javascript/reference/global_objects/array/index.html
new file mode 100644
index 0000000000..6130c8d949
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/index.html
@@ -0,0 +1,511 @@
+---
+title: Array
+slug: Web/JavaScript/Reference/Global_Objects/Array
+tags:
+  - Array
+  - JavaScript
+  - NeedsTranslation
+  - Refer
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Global_Objects/Array
+---
+<p>{{JSRef("Global_Objects", "Array")}}</p>
+
+<h2 id="Sumário">Sumário</h2>
+
+<p>O objeto <code>Array</code> do JavaScript é um objeto global usado na construção de 'arrays': objetos de alto nível semelhantes a listas.</p>
+
+<p><strong>Criando um Array</strong></p>
+
+<pre class="brush: js">var frutas = ['Maçã', 'Banana'];
+
+console.log(frutas.length);
+// 2
+</pre>
+
+<p><strong>Acessar um item (<em>index</em>) do Array</strong></p>
+
+<pre class="brush: js"><code>var primeiro = frutas[0];
+// Maçã
+
+var ultimo = frutas[frutas.length - 1];
+// Banana</code></pre>
+
+<p><strong>Iterar um Array</strong></p>
+
+<pre class="brush: js"><code>frutas.forEach(function (item, indice, array) {
+  console.log(item, indice);
+});
+// Maçã 0
+// Banana 1</code></pre>
+
+<p><strong>Adicionar um item ao final do Array</strong></p>
+
+<pre class="brush: js"><code>var adicionar = frutas.push('Laranja');
+// ['Maçã', 'Banana', 'Laranja']</code></pre>
+
+<p><strong>Remover um item do final do Array</strong></p>
+
+<pre class="brush: js"><code>var ultimo = frutas.pop(); // remove Laranja (do final)
+// ['Maçã', 'Banana'];</code></pre>
+
+<p><strong>Remover do início do Array</strong></p>
+
+<pre class="brush: js"><code>var primeiro = frutas.shift(); // remove Maçã do início
+// ['Banana'];</code></pre>
+
+<p><strong>Adicionar ao início do Array</strong></p>
+
+<pre class="brush: js"><code>var adicionar = frutas.unshift('Morango') // adiciona ao início
+// ['Morango', 'Banana'];</code></pre>
+
+<p><strong>Procurar o índice de um item na Array</strong></p>
+
+<pre class="brush: js"><code>frutas.push('Manga');
+// ['Morango', 'Banana', 'Manga']
+
+var pos = frutas.indexOf('Banana');
+// 1</code></pre>
+
+<p><strong>Remover um item pela posição do índice</strong></p>
+
+<pre class="brush: js"><code>var removedItem = frutas.splice(pos, 1); // é assim que se remove um item
+// ['Morango', 'Manga']</code></pre>
+
+<p><strong>Remover itens de uma posição de índice</strong></p>
+
+<pre class="brush: js">var vegetais = ['Repolho', 'Nabo', 'Rabanete', 'Cenoura'];
+console.log(vegetais);
+// ['Repolho', 'Nabo', 'Rabanete', 'Cenoura']
+
+var pos = 1, n = 2;
+
+var itensRemovidos = vegetais.splice(pos, n);
+// Isso é como se faz para remover itens, n define o número de itens a se remover,
+// a partir da posição (pos) em direção ao fim da array.
+
+console.log(vegetais);
+// ['Repolho', 'Cenoura'] (o array original é alterado)
+
+console.log(itensRemovidos);
+// ['Nabo', 'Rabanete']</pre>
+
+<p><strong>Copiar um Array</strong></p>
+
+<pre class="brush: js"><code>var copiar = frutas.slice(); // é assim que se copia
+// ['Morango', 'Manga']</code></pre>
+
+<p> </p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var><span style="font-style: normal;">[</span>element0</var>, <var>element1</var>, ..., <var>elementN</var>]
+new Array(<em>element0</em>, <em>element1</em>, ..., <em>elementN</em>)
+new Array(<em>arrayLength</em>)
+</pre>
+
+<dl>
+ <dt><code><var>element0</var>, <var>element1</var>, ..., <var>elementN</var> </code></dt>
+ <dd>Um array JavaScript é inicializado com os elementos contém,  exceto no caso onde um único argumento é passado para o construtor do <code>Array</code> e esse argumento é um número (veja o parâmetro arrayLength abaixo).  Esse caso especial só se aplica para os arrays JavaScript criados com o construtor <code>Array</code> , e não para literais de array criados com a sintaxe de colchetes [].</dd>
+ <dt><code><var>arrayLength</var></code></dt>
+ <dd>Se o único argumento passado para o construtor do <code>Array</code> for um número inteiro entre 0 and 2<sup>32</sup>-1 (inclusive), um novo array com o tamanho desse número é retornado. Se o argumento for qualquer outro número, uma exceção <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/RangeError" title="JavaScript/Reference/Global_Objects/RangeError">RangeError</a></code> é lançada.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Arrays são objetos semelhantes a listas que vêm com uma série de  métodos embutidos para realizar operações de travessia e mutação. Nem o tamanho de um array JavaScript nem os tipos de elementos são fixos. Já que  o tamanho de um array pode ser alterado a qualquer momento e os dados podem ser armazenados em posições não contíguas, arrays JavaScript não tem a garantia de serem densos; isso depende de como o programador escolhe usá-los. De uma maneira geral, essas são características convenientes, mas, se esses recursos não são desejáveis para o seu caso em particular, você pode considerar usar arrays tipados.</p>
+
+<p>Arrays não podem usar strings como índices (como em um <a href="https://pt.wikipedia.org/wiki/Vetor_associativo">array associativo</a>), devem ser usados números inteiros. Definir ou acessar não-inteiros usando <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Property_Accessors">notação de colchetes (ou notação de ponto)</a> não vai definir ou recuperar um elemento do array em si, mas sim definir ou acessar uma variável associada com a <a href="/pt-BR/docs/Web/JavaScript/Data_structures#Propriedades">coleção de propriedades de objeto</a> daquele array. As propriedades de objeto do array e a lista de elementos do array são separados, e as operações de travessia e mutação não podem ser aplicadas a essas propriedades nomeadas.</p>
+
+<h3 id="Accessando_elementos_de_um_array">Accessando elementos de um array </h3>
+
+<p>Arrays JavaScript começam com índice zero: o primeiro elemento de um array está na posição <code>0</code> e o último elemento está na  posição equivalente ao valor da propriedade <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/length" title="JavaScript/Reference/Global_Objects/Array/length">length</a></code> (tamanho) menos 1.</p>
+
+<pre class="brush: js">var arr = ['este é o primeiro elemento', 'este é o segundo elemento'];
+console.log(arr[0]);              // exibe '<span style="font-size: 1rem;">este é o primeiro elemento'</span>
+console.log(arr[1]);              // exibe 'este é o segundo elemento'
+console.log(arr[arr.length - 1]); // exibe 'este é o segundo elemento'
+</pre>
+
+<p>Elementos de um array são somente propriedades de objetos, da forma que <code><a href="/en-US/docs/toString" title="toString">toString</a></code> é uma propriedade. Contudo, note que tentando acessar o primeiro elemento de um array da seguinte forma causará um erro de sintaxe, pois o nome da propriedade é inválido:</p>
+
+<pre class="brush: js">console.log(arr.0); // um erro de sintaxe
+</pre>
+
+<p>Não há nada de especial a respeito de arrays JavaScript e suas propriedades que causam isso. As propriedades JavaScript que começam com um dígito não podem ser referenciadas com notação de ponto. Elas necesitam usar notação de colchetes para poderem ser acessadas. Por exemplo, se você tivesse um objeto com a propriedade "3d", também teria que ser referenciá-la usando notação de colchetes. Por exemplo:</p>
+
+<pre class="brush: js">var anos = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
+console.log(anos.0); // um erro de sintaxe
+console.log(anos[0]); // funciona corretamente
+</pre>
+
+<pre class="brush: js">renderer.3d.setTexture(model, 'personagem.png'); // um erro de sintaxe
+renderer['3d'].setTexture(model, 'personagem.png'); //funciona corretamente
+</pre>
+
+<p>Note que no exemplo <code>3d</code>, <code>'3d'</code> teve de ser colocado entre aspas. É possivel também colocar entre aspas os índices de arrays JavaScript (ou seja, <code>years['2']</code> ao invés de <code>years[2]</code>), contudo isto não é necessário. O valor 2 em <code>years[2]</code> eventualmente será convertido a uma string pela engine do JavaScript  através de uma conversão explicita com o método <code>toString</code>. E é por esta razão que  <code>'2'</code> e <code>'02'</code> irão referenciar dois slots diferentes no objeto <code>anos</code> e o seguinte exemplo pode ser <em><code>true</code></em>:</p>
+
+<pre class="brush: js">console.log(anos['2'] != anos['02']);
+</pre>
+
+<p>De forma similar, propriedades de objeto que sejam palavras reservadas(!) só podem ser acessadas como strings em notação de colchetes:</p>
+
+<pre class="brush: js">var promessa = {
+  'var': 'texto',
+  'array': [1, 2, 3, 4]
+};
+
+console.log(promessa['var']);
+</pre>
+
+<h3 id="Relação_entre_length_e_propriedades_numéricas">Relação entre <em><code>length</code></em> e propriedades numéricas</h3>
+
+<p>As propriedades <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/length" title="JavaScript/Reference/Global_Objects/Array/length">length</a></code> e numéricas de um array Javascript são conectadas. Varios dos métodos javascript pré-definidos (por exemplo, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/join" title="JavaScript/Reference/Global_Objects/Array/join">join</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/slice" title="JavaScript/Reference/Global_Objects/Array/slice">slice</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/indexOf" title="JavaScript/Reference/Global_Objects/Array/indexOf">indexOf</a></code> etc.) levam em conta o valor da propriedade <code>length</code> de um array quando eles são chamados. Outros métodos (por exemplo, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/push" title="JavaScript/Reference/Global_Objects/Array/push">push</a></code>, <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/splice" title="JavaScript/Reference/Global_Objects/Array/splice">splice</a></code> etc.) também resultam em uma atualização na propriedade <code>length</code> do array.</p>
+
+<pre class="brush: js">var frutas = [];
+frutas.push('banana', 'maça', 'pêssego');
+
+console.log(frutas.length); // 3</pre>
+
+<p>Quando configurar uma propriedade num array Javascript em que a propriedade é um índice valido do array e este índice está fora do atual limite do array, o array irá crescer para um tamanho grande o suficiente para acomodar o elemento neste índice, e a engine irá atualizar a propriedade <em>length</em> do array de acordo com isto:</p>
+
+<pre class="brush: js">frutas[5] = 'manga';
+console.log(frutas[5]); // 'manga'
+console.log(Object.keys(frutas)); // ['0', '1', '2', '5']
+console.log(frutas.length); // 6</pre>
+
+<p>Configurar a propriedade <code>length</code> diretamente, também resulta em um comportamento especial:</p>
+
+<pre class="brush: js">frutas.length = 10;
+console.log(Object.keys(frutas)); // ['0', '1', '2', '5']
+console.log(frutas.length); // 10
+</pre>
+
+<p>Diminuir o valor de <code>length</code>, entretanto, apaga elementos:</p>
+
+<pre class="brush: js">frutas.length = 2;
+console.log(Object.keys(frutas)); // ['0', '1']
+console.log(frutas.length); // 2</pre>
+
+<h3 id="Criando_um_array_usando_o_resultado_de_uma_comparação">Criando um array usando o resultado de uma comparação</h3>
+
+<p>O resultado de uma comparação entre uma <em>expressão regular</em> e uma string pode criar um array Javascript. Este array tem propriedades e elementos que disponibilizam informações sobre a comparação. Esse array é o valor de retorno dos métodos {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}}, e {{jsxref("String.replace")}}. Para explicar melhor sobre estas propriedades e elementos, veja o seguinte exemplo e então consulte a tabela abaixo:</p>
+
+<pre class="brush: js">// Encontra um d seguido por um ou mais b's seguido por um d
+// Salva os b's encontrados e o d seguinte
+// Ignora caixa (maiúscula/minúscula)
+
+var minhaRegex = /d(b+)(d)/i;
+var meuArray = minhaRegex.exec('cdbBdbsbz');
+</pre>
+
+<p>As propriedades e elementos retornados desta comparação são os seguintes:</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header">Propriedade/Elemento</td>
+   <td class="header">Descrição</td>
+   <td class="header">Exemplo</td>
+  </tr>
+  <tr>
+   <td><code>input</code></td>
+   <td>
+    <p>Uma propriedade somente-leitura que reflete a string original a qual a expressão regular foi comparada.</p>
+   </td>
+   <td>cdbBdbsbz</td>
+  </tr>
+  <tr>
+   <td><code>index</code></td>
+   <td>Uma propriedade somente-leitura que é o índice baseado em zero da comparação na string.</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td><code>[0]</code></td>
+   <td>Um elemento somente-leitura que especifica os ultimos caracteres que foram encontrados.</td>
+   <td>dbBd</td>
+  </tr>
+  <tr>
+   <td><code>[1], ...[n]</code></td>
+   <td>Elementos somente-leitura que especificam as <em>substrings</em> de comparações entre parênteses encontradas, se incluidas na expressão regular. O número de possíveis <em>substrings </em>entre parenteses é ilimitado.</td>
+   <td>[1]: bB<br>
+    [2]: d</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>Array.length</code></dt>
+ <dd>Propriedade comprimento do construtor <code>Array</code>, cujo valor é 1.</dd>
+ <dt>{{jsxref("Array.@@species", "get Array[@@species]")}}</dt>
+ <dd>A função de construtor que é utilizada para criar objetos derivados.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Array.prototype")}}</dt>
+ <dd>Permite a adição de propriedades para todos os objetos array.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<div>
+<dl>
+ <dt>{{jsxref("Array.from()")}}</dt>
+ <dd>Cria uma nova instância de <code>Array</code> a partir de um objeto semelhante ou iterável.</dd>
+ <dt>{{jsxref("Array.isArray()")}}</dt>
+ <dd>Retorna <code>true</code> se a variável é um array e <code>false</code> caso contrário.</dd>
+ <dt>{{jsxref("Array.of()")}}</dt>
+ <dd>Cria uma nova instância de <code>Array</code> com um número variável de argumentos, independentemente do número ou tipo dos argumentos.</dd>
+</dl>
+</div>
+
+<div> </div>
+
+<h2 id="Instâncias_de_Array">Instâncias de <code>Array</code></h2>
+
+<p>Todas as instâncias de <code>Array</code> herdam de <span style="font-family: monospace;"><code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Array/prototype" title="Core_JavaScript_1.5_Reference/Global_Objects/Array/prototype">Array.prototype</a></code></span>.  O protótipo do construtor <code>Array</code> pode ser modificado de forma a afetar todas as instâncias de <code>Array</code>.</p>
+
+<h3 id="Properties_of_Array_instances" name="Properties_of_Array_instances">Propriedades</h3>
+
+<div>{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties') }}</div>
+
+<h3 id="Methods_of_Array_instances" name="Methods_of_Array_instances">Métodos</h3>
+
+<h4 id="Métodos_modificadores">Métodos modificadores</h4>
+
+<div>{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods') }}</div>
+
+<h4 id="Métodos_de_acesso"><span>Métodos de acesso</span></h4>
+
+<div>{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods') }}</div>
+
+<h4 id="Métodos_de_iteração"><span>Métodos de iteração</span></h4>
+
+<div>{{ page('/pt-BR/docs/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods') }}</div>
+
+<h2 id="Métodos_genéricos_de_Array">Métodos genéricos de <code>Array</code></h2>
+
+<div class="warning">
+<p><strong>Métodos genéricos de arrays não seguem o padrão, são obsoletos e serão removidos em breve.</strong></p>
+</div>
+
+<p>Algumas vezes você poderá querer aplicar métodos de arrays para strings ou outros objetos parecidos com arrays (como em <code><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments">argumentos</a></code> de funções). Ao fazer isto, você trata uma string como um array de caracteres (ou em outros casos onde trata-se não-arrays como um array).  Por exemplo,  para checar se cada caractere em uma varivável <var>str</var> é uma letra, você poderia escrever:</p>
+
+<pre class="brush: js">function isLetter(character) {
+  return (character &gt;= "a" &amp;&amp; character &lt;= "z");
+}
+
+if (Array.prototype.every.call(str, isLetter))
+  alert("A string '" + str + "' contém somente letras!");
+</pre>
+
+<p>Esta notação é um pouco despendiosa e o JavaScript 1.6 introduziu a seguinte abreviação genérica:</p>
+
+<pre class="brush: js">if (Array.every(isLetter, str))
+  alert("A string '" + str + "' contém somente letras!");
+</pre>
+
+<p><a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String#String_generic_methods" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String#String_generic_methods">Generics</a> também estão disponíveis em <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String" title="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Global_Objects/String"><code>String</code></a>.</p>
+
+<p>Estes não são atualmente parte dos padrões ECMAScript (através do ES2015 <a href="https://github.com/monolithed/ECMAScript-6" title="https://github.com/monolithed/ECMAScript-5"><code>Array.from()</code></a> pode se conseguir isto). A seguir segue uma adaptação para permitir o uso em todos os navegadores:</p>
+
+<pre class="brush: js">/*globals define*/
+// Assumes Array extras already present (one may use shims for these as well)
+(function () {
+    'use strict';
+
+    var i,
+        // We could also build the array of methods with the following, but the
+        //   getOwnPropertyNames() method is non-shimable:
+        // Object.getOwnPropertyNames(Array).filter(function (methodName) {return typeof Array[methodName] === 'function'});
+        methods = [
+            'join', 'reverse', 'sort', 'push', 'pop', 'shift', 'unshift',
+            'splice', 'concat', 'slice', 'indexOf', 'lastIndexOf',
+            'forEach', 'map', 'reduce', 'reduceRight', 'filter',
+            'some', 'every', 'isArray'
+        ],
+        methodCount = methods.length,
+        assignArrayGeneric = function (methodName) {
+            var method = Array.prototype[methodName];
+            Array[methodName] = function (arg1) {
+                return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
+            };
+        };
+
+    for (i = 0; i &lt; methodCount; i++) {
+        assignArrayGeneric(methods[i]);
+    }
+}());</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_Criando_um_array">Exemplo: Criando um array</h3>
+
+<p>O exemplo a seguir cria um array, <code>msgArray</code>, com <em>length</em> 0, então atribui valores para <code>msgArray[0]</code> e <code>msgArray[99]</code>, trocando o <em>length</em> do array para 100.</p>
+
+<pre class="brush: js">var msgArray = new Array();
+msgArray[0] = "Hello";
+msgArray[99] = "world";
+
+if (msgArray.length == 100)
+   print("O length é 100.");
+</pre>
+
+<h3 id="Exemplo_Criando_um_array_bi-dimensional">Exemplo: Criando um array bi-dimensional</h3>
+
+<p>O exemplo a seguir cria um tabuleiro de xadrez usando dois arrays bi-dimensionais de string. A primeira jogada é feita copiando o 'p' em 6,4 para 4,4.  A posição antiga de 6,4 é colocada em branco.</p>
+
+<pre class="brush: js">var board =
+[ ['R','N','B','Q','K','B','N','R'],
+  ['P','P','P','P','P','P','P','P'],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  [' ',' ',' ',' ',' ',' ',' ',' '],
+  ['p','p','p','p','p','p','p','p'],
+  ['r','n','b','q','k','b','n','r']];
+print(board.join('\n') + '\n\n');
+
+// Fazendo o King's Pawn avançar 2
+board[4][4] = board[6][4];
+board[6][4] = ' ';
+print(board.join('\n'));
+</pre>
+
+<p>Saída:</p>
+
+<pre class="eval">R,N,B,Q,K,B,N,R
+P,P,P,P,P,P,P,P
+ , , , , , , ,
+ , , , , , , ,
+ , , , , , , ,
+ , , , , , , ,
+p,p,p,p,p,p,p,p
+r,n,b,q,k,b,n,r
+
+R,N,B,Q,K,B,N,R
+P,P,P,P,P,P,P,P
+ , , , , , , ,
+ , , , , , , ,
+ , , , ,p, , ,
+ , , , , , , ,
+p,p,p,p, ,p,p,p
+r,n,b,q,k,b,n,r
+</pre>
+
+<h3 id="Browser_compatibility" name="Browser_compatibility">Utilizando um array para tabular um conjunto de valores</h3>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js">values <span class="operator token">=</span> <span class="punctuation token">[</span><span class="punctuation token">]</span><span class="punctuation token">;</span>
+<span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> x <span class="operator token">=</span> <span class="number token">0</span><span class="punctuation token">;</span> x <span class="operator token">&lt;</span> <span class="number token">10</span><span class="punctuation token">;</span> x<span class="operator token">++</span><span class="punctuation token">)</span><span class="punctuation token">{</span>
+ values<span class="punctuation token">.</span><span class="function token">push</span><span class="punctuation token">(</span><span class="punctuation token">[</span>
+  <span class="number token">2</span> <span class="operator token">*</span><span class="operator token">*</span> x<span class="punctuation token">,</span>
+  <span class="number token">2</span> <span class="operator token">*</span> x <span class="operator token">*</span><span class="operator token">*</span> <span class="number token">2</span>
+ <span class="punctuation token">]</span><span class="punctuation token">)</span>
+<span class="punctuation token">}</span><span class="punctuation token">;</span>
+console<span class="punctuation token">.</span><span class="function token">table</span><span class="punctuation token">(</span>values<span class="punctuation token">)</span></code></pre>
+
+<p>Saída:</p>
+
+<pre class="eval line-numbers  language-html"><code class="language-html">0	1	0
+1	2	2
+2	4	8
+3	8	18
+4	16	32
+5	32	50
+6	64	72
+7	128	98
+8	256	128
+9	512	162</code></pre>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Especificações</h2>
+
+<table>
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4', 'Array')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Novos metodos adicionados: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array-objects', 'Array')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Novos metodos adicionados: {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array-objects', 'Array')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Novo metodo adicionado: {{jsxref("Array.prototype.includes()")}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com os navegadores</h2>
+
+<p>{{ CompatibilityTable }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown }}</td>
+   <td>{{ CompatVersionUnknown }}</td>
+   <td>{{ CompatVersionUnknown }}</td>
+   <td>{{ CompatVersionUnknown }}</td>
+   <td>{{ CompatVersionUnknown }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Phone</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown }}</td>
+   <td>{{ CompatVersionUnknown }}</td>
+   <td>{{ CompatVersionUnknown }}</td>
+   <td>{{ CompatVersionUnknown }}</td>
+   <td>{{ CompatVersionUnknown }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Ver também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/JavaScript/Guide/Working_with_Objects#Indexing_object_properties" title="JavaScript/Guide/Working_with_objects#Indexing_object_properties">"Indexing object properties" in JavaScript Guide: "Working with objects"</a></li>
+ <li><a href="/en-US/docs/JavaScript/New_in_JavaScript/1.7#Array_comprehensions" title="New_in_JavaScript_1.7#Array_comprehensions">New in JavaScript 1.7: Array comprehensions</a></li>
+ <li><a href="/en-US/docs/JavaScript/New_in_JavaScript/1.6#Array_extras" title="New_in_JavaScript_1.6#Array_extras">New in JavaScript 1.6: Array extras</a></li>
+ <li><a href="/en-US/docs/JavaScript_typed_arrays" title="JavaScript_typed_arrays">Draft: Typed Arrays</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html b/files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html
new file mode 100644
index 0000000000..1cb6328be8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/indexof/index.html
@@ -0,0 +1,186 @@
+---
+title: Array.prototype.indexOf()
+slug: Web/JavaScript/Reference/Global_Objects/Array/indexOf
+tags:
+  - Array
+  - JavaScript
+  - Método(2)
+  - Prototype
+  - Referência(2)
+  - polyfill
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/indexOf
+---
+<div>{{JSRef}}</div>
+
+<div>O método <code><strong>indexOf() </strong></code>retorna o primeiro índice em que o elemento pode ser encontrado no array, retorna -1 caso o mesmo não esteja presente.</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>array</var>.indexOf(<var>elementoDePesquisa</var>, [pontoInicial = 0])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>elementoDePesquisa</code></dt>
+ <dd><code>Elemento a ser pesquisado no array.</code></dd>
+ <dt><code>pontoInicial</code></dt>
+ <dd>O índice para iniciar a procura. Se o índice for maior ou igual ao tamanho do array, é retornado -1 e signfica que o item não será procurado. Se o<code> pontoInicial é fornecido</code> com um número negativo,  é tomado como deslocamento da extremidade do array. Nota: se o <code>pontoInicial</code> fornecido é negativo, a procura no array acontece de frente para trás. Se o <code>pontoInicial</code> fornecido é 0, então o array inteiro será pesquisado. Padrão: 0 (pesquisa em todo array).</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>indexOf()</code> compara o  <code>elementoDePesquisa</code> com os elementos do Array usando <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators">igualdade estrita</a> (o mesmo método usado pelo ===, ou triple-equals operator). </p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_indexOf">Usando <code>indexOf()</code></h3>
+
+<p><code>O exemplo seguinte usa indexOf() para localizar valores em um array</code></p>
+
+<pre class="brush: js notranslate">var array = [2, 5, 9];
+array.indexOf(2);     // 0
+array.indexOf(7);     // -1
+array.indexOf(9, 2);  // 2
+array.indexOf(2, -1); // -1
+array.indexOf(2, -3); // 0
+</pre>
+
+<h3 id="Encontrar_todas_as_ocorrências_de_um_elemento">Encontrar todas as ocorrências de um elemento</h3>
+
+<pre class="brush: js notranslate">var indices = [];
+var array = ['a', 'b', 'a', 'c', 'a', 'd'];
+var elemento = 'a';
+var idx = array.indexOf(elemento);
+while (idx != -1) {
+  indices.push(idx);
+  idx = array.indexOf(elemento, idx + 1);
+}
+console.log(indices);
+// [0, 2, 4]
+</pre>
+
+<h3 id="Encontrar_se_um_elemento_existe_ou_não_e_atualizar_o_array">Encontrar se um elemento existe ou não e atualizar o array</h3>
+
+<pre class="brush: js notranslate">function atualizarColecaoVegetais (vegetais, vegetal) {
+    if (vegetais.indexOf(vegetal) === -1) {
+        vegetais.push(vegetal);
+        console.log('Nova coleção de vegetais é : ' + vegetais);
+    } else if (vegetais.indexOf(vegetal) &gt; -1) {
+        console.log(vegetal + ' já existe na coleção de vegetais.');
+    }
+}
+
+var vegetais = ['batata', 'tomate', 'pimenta', 'pimentao'];
+
+atualizarColecaoVegetais(vegetais, 'espinafre');
+// Nova coleção de vegatais é : batata,tomate,pimenta,pimentao,espinafre
+atualizarColecaoVegetais(vegetais, 'espinafre');
+// espinafre já existe na coleção de vegetais.
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p><code>indexOf() </code>foi adicionado ao ECMA-262 standard em sua 5 edição; como tal, não pode estar presente em todos navegadores.Você pode contornar isso utilizando o seguinte codigo no inicio de seus scripts. Isto permitirá que voce use o <code>indexOf() </code>quando não possuir suporte nativo. Esse algoritmo corresponde ao especificado no ECMA-262, edição 5, assumindo {{jsxref("Global_Objects/TypeError", "TypeError")}} e {{jsxref("Math.abs()")}} tem seus valores originais.</p>
+
+<pre class="brush: js notranslate">// Passos para a produção do ECMA-262, Edition 5, 15.4.4.14
+// Referência: http://es5.github.io/#x15.4.4.14
+if (!Array.prototype.indexOf) {
+  Array.prototype.indexOf = function(elementoDePesquisa, pontoInicial) {
+
+    var k;
+
+    //1. Deixe-o ser o resultado da chamada de toObject
+    // passando o valor de this como argumento.
+    if (this == null) {
+      throw new TypeError('"this" é nulo (null) ou não foi definido (undefined)');
+    }
+
+    var O = Object(this);
+
+    // 2. Deixar o tamanhoValor ser o resultado da
+    // chamada do método interno Get de 0 com o
+    // argumento "length"
+    // 3. Deixar o  tamanhoValor ser um ToUint32(tamanhoValor).
+    var tamanho = O.length &gt;&gt;&gt; 0;
+
+    // 4. se o tamanho é 0, retorna -1.
+    if (tamanho === 0) {
+      return -1;
+    }
+
+    // 5. Se o argumento pontoInicial for passado,
+    // use o ToInteger(pontoInicial); senao use 0.
+    var n = + pontoInicial || 0;
+
+    if (Math.abs(n) === Infinity) {
+      n = 0;
+    }
+
+    //6. Se n &gt;= tamanho, retorna -1.
+    if (n &gt;= tamanho) {
+      return -1;
+    }
+
+    // 7. Se n&gt;= 0, entao k seja n.
+    // 8. Senao, n&lt;0, k seja tamanho - abs(n).
+    // Se k é menor que 0, entao k seja 0.
+    k = Math.max(n &gt;= 0 ? n : tamanho - Math.abs(n), 0);
+
+    // 9. Repita, enquanto k &lt; tamanho
+    while (k &lt; tamanho) {
+      // a. Deixe Pk ser ToString(k).
+      //    isto é implicito para operandos LHS de um operador
+
+      // b. Deixe o kPresent  ser o resultado da chamada do método
+      //    interno de 0 com argumento Pk
+      //    Este passo pode ser combinado com c.
+      // c. Se kPresent é true, entao
+      //    i.  Deixe o  elementK ser o resultado da chamada do metodo
+      //        interno Get de 0 com argumento ToString(k)
+      //   ii.  Deixe o resultado ser aplicado pelo Algoritmo de
+      //        Comparação de Igualdade Estrita (Strict Equality Comparison)
+      //        para o elementoDePesquisa e elementK
+      //  iii.  caso verdadeiro, retorne k.
+      if (k in O &amp;&amp; O[k] === elementoDePesquisa) {
+        return k;
+      }
+      k++;
+    }
+    return -1;
+  };
+}</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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.14', 'Array.prototype.indexOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>
+    <p>Definição inicial implementada no Javascript 1.6.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.indexof', 'Array.prototype.indexOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_Navegadores">Compatibilidade entre Navegadores</h2>
+
+<div id="compat-mobile">{{Compat("javascript.builtins.Array.indexOf")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.indexOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html b/files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html
new file mode 100644
index 0000000000..328790b8e9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/isarray/index.html
@@ -0,0 +1,141 @@
+---
+title: Array.isArray()
+slug: Web/JavaScript/Reference/Global_Objects/Array/isArray
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/isArray
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p><font face="Open Sans, Arial, sans-serif">O método </font><code><strong>Array.isArray()</strong></code> retorna <code>true</code> se um objeto é uma array, e <code>false</code> se não é.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Array.isArray(<var>obj</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto a ser verificado.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Se o objeto é um {{jsxref("Array")}}, retorna <code>true</code>(verdadeiro), caso contrário é retornado <code>false</code>(falso).</p>
+
+<p>Veja o artigo <a href="http://web.mit.edu/jwalden/www/isArray.html">“Determinando com absoluta precisão se um objeto em Javascript é ou não uma array”</a> para mais detalhes.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<pre class="brush: js">// todas as chamadas conseguintes retornam <code style="font-style: normal;">true</code>
+Array.isArray([]);
+Array.isArray([1]);
+Array.isArray(new Array());
+// Pequeno detalhe: Array.prototype por si só é uma array:
+Array.isArray(Array.prototype);
+
+// todas as conseguintes retornam false
+Array.isArray();
+Array.isArray({});
+Array.isArray(null);
+Array.isArray(undefined);
+Array.isArray(17);
+Array.isArray('Array');
+Array.isArray(true);
+Array.isArray(false);
+Array.isArray({ __proto__: Array.prototype });
+</pre>
+
+<h2 id="Polyfill" name="Polyfill">Polyfill</h2>
+
+<p>Executando o seguinte código antes de qualquer outro, o método <code>Array.isArray()</code> será criado, caso o browser não o disponibilize nativamente.</p>
+
+<pre class="brush: js">if (!Array.isArray) {
+  Array.isArray = function(arg) {
+    return Object.prototype.toString.call(arg) === '[object Array]';
+  };
+}
+</pre>
+
+<h2 id="Specifications" name="Specifications">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('ES5.1', '#sec-15.4.3.2', 'Array.isArray')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição Inicial. Implementado em JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.isarray', 'Array.isArray')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com o Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("10.5")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("2.0")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>Baseado na <a href="http://kangax.github.com/es5-compat-table/">Tabela de Compatibilidade de Kangax</a>.</p>
+
+<h2 id="See_also" name="See_also">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Array", "Array")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/join/index.html b/files/pt-br/web/javascript/reference/global_objects/array/join/index.html
new file mode 100644
index 0000000000..703cc76de0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/join/index.html
@@ -0,0 +1,108 @@
+---
+title: Array.prototype.join()
+slug: Web/JavaScript/Reference/Global_Objects/Array/join
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/join
+---
+<div>{{JSRef}}</div>
+
+<div><font face="Open Sans, Arial, sans-serif">O método </font><code><strong>join()</strong></code> junta todos os elementos de um array (ou um <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">array-like object</a>) em uma string e retorna esta string.</div>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.join([separador = ','])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>separador</code> {{optional_inline}}</dt>
+ <dd>Específica uma string para separar cada elemento adjacente do array. O separador é convertido em uma string se necessário. Se omitido, os elementos do array são separados com uma vírgula (","). Se o <code style="font-style: normal;">separador</code> for uma string vazia, todos os elementos são juntados sem nenhum caracter entre eles.</dd>
+</dl>
+
+<h3 id="Parameters" name="Parameters">Valor de retorno</h3>
+
+<dl>
+ <dd>Uma string com todos os elementos do array juntos. Se <code>arr.length</code> é <code>0</code>, uma string vazia é retornada.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>As conversões em string de todos os elementos de um array são juntados em apenas uma string.</p>
+
+<div class="warning">
+<p>Obs: Se um elemento é <code>undefined</code> ou <code>null</code>, ele é convertido em uma string vazia.</p>
+</div>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Joining_an_array_three_different_ways" name="Example:_Joining_an_array_three_different_ways">Juntando um array de quatro formas diferentes</h3>
+
+<p>O exemplo interativo a seguir cria um array, <code>a</code>, com três elementos, e o junta três vezes: a primeira com virgulas, a segunda so junta os elementos e a terceira com um sinal de menos.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/array-join.html")}} </p>
+
+<div class="hidden">
+<p>O codigo para o exemplo interativo esta disponivel em um repositorio no GitHub. Se você deseja contribuir projeto, clone o repositório <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a>  e nos envie um pull request.</p>
+</div>
+
+
+
+<h3 id="Juntando_um_array-like_object_objeto_estilo-array">Juntando um array-like object (objeto estilo-array)</h3>
+
+<p>O exemplo abaixo junta um array-like object (ex: o objeto <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></code>), chamando {{jsxref("Function.prototype.call")}} no <code>Array.prototype.join</code>.</p>
+
+<pre class="brush: js notranslate"><code>function f(a, b, c) {
+  var s = Array.prototype.join.call(arguments);
+  console.log(s); // '1,a,true'
+}
+f(1, 'a', true);
+//saida esperada: "1,a,true"</code></pre>
+
+
+
+<h2 id="Specifications" name="Specifications">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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.5', 'Array.prototype.join')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.join', 'Array.prototype.join')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array.prototype.join', 'Array.prototype.join')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com o Browser</h2>
+
+<div class="hidden">
+<p>A tabela de compatibilidade nesta pagina é gerada a partir de dados estruturados. Se voce deseja contribuir para os dados, de uma olhada no repositorio <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p>
+</div>
+
+<div>{{Compat("javascript.builtins.Array.join")}}</div>
+
+<h2 id="See_also" name="See_also">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.split()")}}</li>
+ <li>{{jsxref("Array.prototype.toString()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.join()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/keys/index.html b/files/pt-br/web/javascript/reference/global_objects/array/keys/index.html
new file mode 100644
index 0000000000..99a61b896a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/keys/index.html
@@ -0,0 +1,115 @@
+---
+title: Array.prototype.keys()
+slug: Web/JavaScript/Reference/Global_Objects/Array/keys
+tags:
+  - Iteração
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/keys
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O método <code><strong>keys()</strong></code> retorna um novo <code><strong>Array Iterator</strong></code> que contém as chaves para cada <em>index</em> do array.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.keys()</code></pre>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Exemplo_uso_básico">Exemplo: uso básico</h3>
+
+<pre class="brush: js">var arr = ["a", "b", "c"];
+var iterator = arr.keys();
+
+console.log(iterator.next()); // { value: 0, done: false }
+console.log(iterator.next()); // { value: 1, done: false }
+console.log(iterator.next()); // { value: 2, done: false }
+console.log(iterator.next()); // { value: undefined, done: true }
+</pre>
+
+<h3 id="Exemplo_keys_iterator_não_ignora_lacunas">Exemplo: keys iterator não ignora lacunas</h3>
+
+<pre class="brush: js">var arr = ["a", , "c"];
+var sparseKeys = Object.keys(arr);
+var denseKeys = [...arr.keys()];
+console.log(sparseKeys); // [0, 2]
+console.log(denseKeys);  // [0, 1, 2]
+</pre>
+
+<h2 id="Specifications" name="Specifications">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-array.prototype.keys', 'Array.prototype.keys')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatChrome("38")}}</td>
+   <td>{{CompatGeckoDesktop("28")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("25")}}</td>
+   <td>{{CompatSafari("7.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("28")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>iOS 8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.values()")}}</li>
+ <li>{{jsxref("Array.prototype.entries()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html b/files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html
new file mode 100644
index 0000000000..0dc189d7f1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/lastindexof/index.html
@@ -0,0 +1,184 @@
+---
+title: Array.prototype.lastIndexOf()
+slug: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>lastIndexOf()</strong></code> retorna o ultimo índice que um certo elemento pode ser encontrado no array, ou -1 se o elemento não estiver presente. O array é pesquisado de trás para frente, começando pelo <code>fromIndex</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.lastIndexOf(<var>searchElement</var>[, <var>fromIndex</var> = arr.length - 1])</code></pre>
+
+<h2 id="Parâmetros">Parâmetros</h2>
+
+<dl>
+ <dt><code>searchElement</code></dt>
+ <dd>Elemento para ser localizado no array.</dd>
+ <dt><code>fromIndex</code></dt>
+ <dd>Opcional. O índice ao qual a busca será iniciada de traz para frente. O valor padrão é o tamanho total do array menos um (array.length -1), ou seja, todo o array será pesquisado. Se o índice for maior ou igual ao tamanho do array, o array inteiro será pesquisado. Se for negativo, ele é tomado como deslocamento no final do array. Note que mesmo se o índice for negativo, o array ainda será pesquisado de traz para frente. Se o índice calculado for menor que 0, -1 será retornado, ou seja, o array não será pesquisado.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>lastIndexOf</code> compara <code>searchElement</code> a elementos do Array usando <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Using_the_Equality_Operators">igualdade rigorosa</a> (o mesmo método usado pelo operador ===, ou "igual triplo").</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Examplo_Usando_lastIndexOf">Examplo: Usando <code>lastIndexOf</code></h3>
+
+<p>O seguinte exemplo utiliza <code>lastIndexOf</code> para localizar elementos em um array.</p>
+
+<pre class="brush: js">var array = [2, 5, 9, 2];
+array.lastIndexOf(2);     // 3
+array.lastIndexOf(7);     // -1
+array.lastIndexOf(2, 3);  // 3
+array.lastIndexOf(2, 2);  // 0
+array.lastIndexOf(2, -2); // 0
+array.lastIndexOf(2, -1); // 3
+</pre>
+
+<h3 id="Exemplo_Encontrando_todas_as_ocorrências_de_um_elemento">Exemplo: Encontrando todas as ocorrências de um elemento</h3>
+
+<p>O seguinte exemplo utiliza <code>lastIndexOf</code> para encontrar todos os índices de um elemento em um dado array, utilizando {{jsxref("Array.prototype.push", "push")}} para adicioná-los em outro array quando são encontrados.</p>
+
+<pre class="brush: js">var indices = [];
+var array = ['a', 'b', 'a', 'c', 'a', 'd'];
+var element = 'a';
+var idx = array.lastIndexOf(element);
+while (idx != -1) {
+  indices.push(idx);
+  idx = (idx &gt; 0 ? array.lastIndexOf(element, idx - 1) : -1);
+}
+
+console.log(indices);
+// [4, 2, 0]
+</pre>
+
+<p>Note que devemos tratar o caso <code>idx == 0</code> separadamente aqui pois o elemento será sempre encontrado independente do parâmetro <code>fromIndex</code> se ele for o primeiro elemento do array. Isso é diferente do método {{jsxref("Array.prototype.indexOf", "indexOf")}}.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p><code>lastIndexOf</code> foi adicionado ao padrão ECMA-262 na 5ª edição; devido a isso, não deve estar presente em outras implementações do padrão. Você pode contornar isso inserindo o seguinte código no início dos seus scripts, permitindo o uso de <code>lastIndexOf</code> em implementações que não o suportam nativamente. Esse algorítimo é exatamente o mesmo especificado no padrão ECMA-262, 5ª edição, assumindo que {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, {{jsxref("Global_Objects/Number", "Number")}}, {{jsxref("Math.floor")}}, {{jsxref("Math.abs")}}, e {{jsxref("Math.min")}} possuem seus valores originais.</p>
+
+<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.15
+// Reference: http://es5.github.io/#x15.4.4.15
+if (!Array.prototype.lastIndexOf) {
+  Array.prototype.lastIndexOf = function(searchElement /*, fromIndex*/) {
+    'use strict';
+
+    if (this === void 0 || this === null) {
+      throw new TypeError();
+    }
+
+    var n, k,
+      t = Object(this),
+      len = t.length &gt;&gt;&gt; 0;
+    if (len === 0) {
+      return -1;
+    }
+
+    n = len - 1;
+    if (arguments.length &gt; 1) {
+      n = Number(arguments[1]);
+      if (n != n) {
+        n = 0;
+      }
+      else if (n != 0 &amp;&amp; n != (1 / 0) &amp;&amp; n != -(1 / 0)) {
+        n = (n &gt; 0 || -1) * Math.floor(Math.abs(n));
+      }
+    }
+
+    for (k = n &gt;= 0 ? Math.min(n, len - 1) : len - Math.abs(n); k &gt;= 0; k--) {
+      if (k in t &amp;&amp; t[k] === searchElement) {
+        return k;
+      }
+    }
+    return -1;
+  };
+}
+</pre>
+
+<p>Novamente, perceba que essa implementação foca na absoluta compatibilidade com <code>lastIndexOf</code> no Firefox e no motor JavaScript SpiderMonkey, incluíndo vários casos que são, indiscutivelmente, extremos. Se você pretende usar isso em aplicações reais, é possível calcular <code>from</code> com um código menos complicado se você ignorar esses casos.</p>
+
+<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('ES5.1', '#sec-15.4.4.15', 'Array.prototype.lastIndexOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.6.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.lastindexof', 'Array.prototype.lastIndexOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.indexOf()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.lastIndexOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/length/index.html b/files/pt-br/web/javascript/reference/global_objects/array/length/index.html
new file mode 100644
index 0000000000..a03b16502c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/length/index.html
@@ -0,0 +1,128 @@
+---
+title: Array.prototype.length
+slug: Web/JavaScript/Reference/Global_Objects/Array/length
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/length
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code><strong>length</strong></code> representa um inteiro de 32-bit sem sinal, que especifíca o número de elementos em um array.</p>
+
+<div>{{js_property_attributes(1, 0, 0)}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.length</code></pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O valor da propriedade length é um inteiro com um sinal positivo e valor menor que 2 elevado na 32ª potência(2<sup>32</sup>).</p>
+
+<p>Você pode setar o a propriedade <code>length</code> para truncar um array a qualquer momento. Quando você extende um array mudando sua propriedade <code>length</code>, o numero de elementos atuais não é incrementado; por exemplo, se você setar o tamanho para 3 quando ele é atualmente 2, o array continua somente com 2 elementos. Assim, a propriedade <code>length</code> não diz nada sobre o tamanho de valores definidos no array. Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Relationship_between_length_and_numerical_properties" title="Relationship between length and numerical properties">Relacionamento entre <code>length</code> e propriedades numérica</a>s.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Iterando_sobre_um_array">Iterando sobre um array</h3>
+
+<p>No exemplo a seguir <code>numbers </code>é iterado considerando a propriedade <code>length</code> para ver quantos elementos ele tem. O valor de cada elemento recebe então o dobro.</p>
+
+<pre class="brush: js">var numbers = [1, 2, 3, 4, 5];
+
+for (var i = 0; i &lt; numbers.length; i++) {
+  numbers[i] *= 2;
+}
+// numbers is now [2, 4, 6, 8, 10]
+</pre>
+
+<h3 id="Encurtando_um_array">Encurtando um array</h3>
+
+<p>O exemplo a seguir encurta o array  <code>statesUS</code> para um tamanho de 50 se o tamanho corrente for maior do que 50.</p>
+
+<pre class="brush: js">if (statesUS.length &gt; 50) {
+  statesUS.length = 50;
+}
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.5.2', 'Array.length')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-properties-of-array-instances-length', 'Array.length')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/map/index.html b/files/pt-br/web/javascript/reference/global_objects/array/map/index.html
new file mode 100644
index 0000000000..278e9ba6a4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/map/index.html
@@ -0,0 +1,255 @@
+---
+title: Array.prototype.map()
+slug: Web/JavaScript/Reference/Global_Objects/Array/map
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong>map()</strong> invoca a função <code>callback</code> passada por argumento para cada elemento do Array e devolve um novo Array como resultado.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.map(<var>callback</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função cujo retorno produz o elemento do novo Array. Recebe três argumentos:
+ <dl>
+  <dt><code>valorAtual</code></dt>
+  <dd>O valor do elemento original do Array de origem. </dd>
+  <dt><code>indice</code></dt>
+  <dd>O índice do elemento atual que está sendo processado no array.</dd>
+  <dt><code>array</code></dt>
+  <dd>O Array de origem.</dd>
+ </dl>
+ </dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Opcional. Valor a ser utilizado como o <em><code>this</code></em> no momento da execução da função <code>callback</code>.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O método <strong><code>map</code></strong> chama a função <code>callback</code> recebida por parâmetro para cada elemento do Array original, em ordem, e constrói um novo array com base nos retornos de cada chamada. A função <code>callback</code> é chamada apenas para os elementos do array original que tiverem valores atribuídos; os elementos que estiverem como <code>undefined</code>, que tiverem sido removidos ou os que nunca tiveram valores atribuídos não serão considerados.</p>
+
+<p>A função <code>callback</code> é chamada com três argumentos: o valor do elemento corrente, o índice do elemento corrente e o array original que está sendo percorrido.</p>
+
+<p>Se o parametro <code>thisArg</code> foi passado para o método <code>map</code>, ele será repassado para a função <code>callback</code> no momento da invocação para ser utilizado como o <code>this</code>. Caso contrário, o valor {{jsxref("Global_Objects/undefined", "undefined")}} será repassado para uso como o <em><code>this</code></em>. O valor do <code>this</code> a ser repassado para o <code>callback</code> deve respeitar as <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">regras para determinar como o this é acessado por uma função</a> (em inglês).</p>
+
+<p>O método <code>map</code> não modifica o array original. No entanto, a função <code>callback</code> invocada por ele pode fazê-lo.</p>
+
+<p>A lista de elementos que serão processados pelo <code>map</code> é montada antes da primeira invocação à função <code>callback</code>. Se um elemento for acrescentado ao array original após a chamada ao <code>map</code>, ele não será visível para o <code>callback</code>. Se os elementos existentes forem modificados, os valores que serão repassados serão os do momento em que o método <code>map</code> invocar o <code>callback</code>. Elementos removidos não serão visitados.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Mapping_an_array_of_numbers_to_an_array_of_square_roots" name="Example:_Mapping_an_array_of_numbers_to_an_array_of_square_roots">Exemplo: Mapeando um array de números para um array de raízes quadradas</h3>
+
+<p>O código a seguir mapeia um array de números e cria um novo array contendo o valor da raiz quadrada de cada número do primeiro array.</p>
+
+<pre class="brush: js">var numbers = [1, 4, 9];
+var roots = numbers.map(Math.sqrt);
+// roots é [1, 2, 3], numbers ainda é [1, 4, 9]
+</pre>
+
+<h3 id="Example_Mapping_an_array_of_numbers_using_a_function_containing_an_argument" name="Example:_Mapping_an_array_of_numbers_using_a_function_containing_an_argument">Exemplo: Mapeando um array de números usando uma função <code>callback</code> que contém um argumento</h3>
+
+<p>O código a seguir mostrar como o método <code>map</code> funciona quando a função <code>callback</code> possui apenas um argumento. Esse argumento será automaticamente atribuído para cada elemento do array conforme o <code>map</code> itera sobre o array original.</p>
+
+<pre class="brush: js">var numbers = [1, 4, 9];
+var doubles = numbers.map(function(num) {
+  return num * 2;
+});
+// doubles é agora [2, 8, 18]. numbers ainda é [1, 4, 9]
+</pre>
+
+<h3 id="Example_using_map_generically" name="Example:_using_map_generically">Exemplo: usando <code>map</code> genericamente</h3>
+
+<p>Esse exemplo demonstra como usar o map em um {{jsxref("Global_Objects/String", "String")}} para recuperar a representação em ASCII de cada caracter em um array de bytes:</p>
+
+<pre class="brush: js">var map = Array.prototype.map;
+var a = map.call('Hello World', function(x) { return x.charCodeAt(0); });
+// a agora vale [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
+</pre>
+
+<h3 id="Example_using_map_generically_querySelectorAll" name="Example:_using_map_generically_querySelectorAll">Exemplo: usando <code>map</code> genericamente com <code>querySelectorAll</code></h3>
+
+<p>Esse exemplo demonstra como iterar sobre uma coleção de objetos recuperada através de querySelectorAll. Nesse caso, vamos pegar todos os options selecionados na tela e imprimir no console:</p>
+
+<pre class="brush: js">var elems = document.querySelectorAll('select option:checked');
+var values = [].map.call(elems, function(obj) {
+  return obj.value;
+});
+</pre>
+
+<h3 id="Exemplo_Usando_map_para_inverter_uma_string">Exemplo: Usando <code>map</code> para inverter uma string</h3>
+
+<pre class="brush: js">var str = '12345';
+[].map.call(str, function(x) {
+  return x;
+}).reverse().join('');
+
+// Output: '54321'
+// Bonus: utilize '===' para verificar se a string original e a nova string são palíndromos
+</pre>
+
+<h3 id="Example_Tricky_use_case" name="Example:_Tricky_use_case">Exemplo: Caso de uso mais complexo</h3>
+
+<p><a href="http://www.wirfs-brock.com/allen/posts/166">(inspirado nesse post)</a> (em inglês)</p>
+
+<p>É uma prática comum utilizar o callback com apenas um argumento (o elemento atual do array original). Algumas funções também são comumente utilizadas com um argumento, mesmo tendo argumentos adicionais opcionais. Esses hábitos podem resultar em comportamentos indesejado:</p>
+
+<pre class="brush: js">// Considere:
+['1', '2', '3'].map(parseInt);
+// Enquanto era de se esperar [1, 2, 3]
+// O resultado atual é [1, NaN, NaN]
+
+// <code>parseInt é normalmente usado com apenas um argumento, mas ele possui dois</code>.
+// O primeiro é uma expressão, e o segundo o radical.
+// Para a função callback, o Array.prototype.map repassa 3 argumentos:
+// o elemento corrente, o indice e o array original
+// O terceiro argumento é ignorado pelo parseInt, mas o segundo não, o que certamente gerou o comportamento inesperado. Veja o post para maiores detalhes
+
+function returnInt(element) {
+  return parseInt(element, 10);
+}
+
+['1', '2', '3'].map(returnInt); // [1, 2, 3]
+// O resultado atual é um array de números (como esperado)
+
+// Bonus: Um jeito mais simples de conseguir o mesmo resultado sem nenhuma "pegadinha do Malandro":
+['1', '2', '3'].map(Number); // [1, 2, 3]
+</pre>
+
+<h2 id="Polyfill" name="Polyfill">Polyfill</h2>
+
+<p>(veja definição em <a href="https://pt.wikipedia.org/wiki/Polyfill">Polyfill</a>)</p>
+
+<p>O método <code>map</code> foi introduzido ao padrão ECMA-262 na sua 5ª edição, o que significa que ele pode não estar presente em todas as implementações desse padrão. Você pode contornar esse problema inserindo o código a seguir no início dos seus scripts, permitindo o uso do <code>map</code> mesmo que ele não esteja sendo suportado nativamente. Esse algoritmo é exatamente o especificado no ECMA-262 5ª edição, assumindo que {{jsxref("Global_Objects/Object", "Object")}}, {{jsxref("Global_Objects/TypeError", "TypeError")}}, e {{jsxref("Global_Objects/Array", "Array")}} tenham seus valores originais, e que <code style="font-style: normal;">callback.call</code> avalie para o valor original de <code style="font-style: normal;">{{jsxref("Function.prototype.call")}}</code>.</p>
+
+<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.19
+// Reference: http://es5.github.io/#x15.4.4.19
+if (!Array.prototype.map) {
+
+  Array.prototype.map = function(callback, thisArg) {
+
+    var T, A, k;
+
+    if (this == null) {
+      throw new TypeError(' this is null or not defined');
+    }
+
+    //  1. Let O be the result of calling ToObject passing the |this|
+    //    value as the argument.
+    var O = Object(this);
+
+    // 2. Let lenValue be the result of calling the Get internal
+    //    method of O with the argument "length".
+    // 3. Let len be ToUint32(lenValue).
+    var len = O.length &gt;&gt;&gt; 0;
+
+    // 4. If IsCallable(callback) is false, throw a TypeError exception.
+    // See: http://es5.github.com/#x9.11
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' is not a function');
+    }
+
+    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+    if (arguments.length &gt; 1) {
+      T = thisArg;
+    }
+
+    // 6. Let A be a new array created as if by the expression new Array(len)
+    //    where Array is the standard built-in constructor with that name and
+    //    len is the value of len.
+    A = new Array(len);
+
+    // 7. Let k be 0
+    k = 0;
+
+    // 8. Repeat, while k &lt; len
+    while (k &lt; len) {
+
+      var kValue, mappedValue;
+
+      // a. Let Pk be ToString(k).
+      //   This is implicit for LHS operands of the in operator
+      // b. Let kPresent be the result of calling the HasProperty internal
+      //    method of O with argument Pk.
+      //   This step can be combined with c
+      // c. If kPresent is true, then
+      if (k in O) {
+
+        // i. Let kValue be the result of calling the Get internal
+        //    method of O with argument Pk.
+        kValue = O[k];
+
+        // ii. Let mappedValue be the result of calling the Call internal
+        //     method of callback with T as the this value and argument
+        //     list containing kValue, k, and O.
+        mappedValue = callback.call(T, kValue, k, O);
+
+        // iii. Call the DefineOwnProperty internal method of A with arguments
+        // Pk, Property Descriptor
+        // { Value: mappedValue,
+        //   Writable: true,
+        //   Enumerable: true,
+        //   Configurable: true },
+        // and false.
+
+        // In browsers that support Object.defineProperty, use the following:
+        // Object.defineProperty(A, k, {
+        //   value: mappedValue,
+        //   writable: true,
+        //   enumerable: true,
+        //   configurable: true
+        // });
+
+        // For best browser support, use the following:
+        A[k] = mappedValue;
+      }
+      // d. Increase k by 1.
+      k++;
+    }
+
+    // 9. return A
+    return A;
+  };
+}
+</pre>
+
+<h2 id="Specifications" name="Specifications">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('ES5.1', '#sec-15.4.4.19', 'Array.prototype.map')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial implementada no JavaScript 1.6.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.map', 'Array.prototype.map')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com os browsers</h2>
+
+<div>{{Compat("javascript.builtins.Array.map")}}</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Map")}} object</li>
+ <li>{{jsxref("Array.from()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/observe/index.html b/files/pt-br/web/javascript/reference/global_objects/array/observe/index.html
new file mode 100644
index 0000000000..d1b06c5ecf
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/observe/index.html
@@ -0,0 +1,128 @@
+---
+title: Array.observe()
+slug: Web/JavaScript/Reference/Global_Objects/Array/observe
+translation_of: Archive/Web/JavaScript/Array.observe
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O método <strong><code>Array.observe()</code></strong> é usado para observar mudanças de forma assíncrona em Arrays, de forma similar ao método {{jsxref("Object.observe()")}} para objetos. O método fornece um conjunto de mudanças em ordem de ocorrência. É equivalente ao método <code>Object.observe()</code> invocado com a lista aceita <code>["add", "update", "delete", "splice"]</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Array.observe(<var>arr</var>, <var>callback</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>arr</code></dt>
+ <dd>O array a ser observado.</dd>
+ <dt><code>callback</code></dt>
+ <dd>A função chamado cada vez que ocorrem mudanças, com o seguinte argumento:
+ <dl>
+  <dt><code>changes</code></dt>
+  <dd>Um array de objetos, sendo que cada um representa uma mudança. As propriedades destes objetos são:
+  <ul>
+   <li><strong><code>name</code></strong>: O nome da propriedade que mudou.</li>
+   <li><strong><code>object</code></strong>: O array modificado depois que a mudança ocorreu.</li>
+   <li><strong><code>type</code></strong>: Uma string que indica o tipo de mudança que ocorreu. Pode ser <code>"add"</code>, <code>"update"</code>, <code>"delete"</code>, ou <code>"splice"</code>.</li>
+   <li><strong><code>oldValue</code></strong>: Apenas para os tipos <code>"update"</code> e <code>"delete"</code>. O valor antes da mudança.</li>
+   <li><strong><code>index</code></strong>: Apenas para o tipo <code>"splice"</code>. O índice no qual ocorreu a mudança.</li>
+   <li><strong><code>removed</code></strong>: Apenas para o tipo <code>"splice"</code>. Um array de elementos removidos.</li>
+   <li><strong><code>addedCount</code></strong>: Apenas para o tipo <code>"splice"</code>. O número de elementos adicionados.</li>
+  </ul>
+  </dd>
+ </dl>
+ </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função <code>callback</code> é chamada cada vez que uma mudança é feita em <code>arr</code>, com um array de todas as mudanças na ordem em que elas ocorreram.</p>
+
+<div class="note">
+<p>Mudanças feitas via métodos de Array, tais como <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop"><code>Array.prototype.pop()</code></a> serão reportados como mudanças do tipo <code>"splice"</code>. Mudanças do tipo índice que não alteram o tamanho do array podem ser reportadas como mudanças do tipo <code>"update"</code>.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Adicionando_diferentes_tipos_em_log">Adicionando diferentes tipos em log</h3>
+
+<pre class="brush: js">var arr = ['a', 'b', 'c'];
+
+Array.observe(arr, function(changes) {
+  console.log(changes);
+});
+
+arr[1] = 'B';
+// [{type: 'update', object: &lt;arr&gt;, name: '1', oldValue: 'b'}]
+
+arr[3] = 'd';
+// [{type: 'splice', object: &lt;arr&gt;, index: 3, removed: [], addedCount: 1}]
+
+arr.splice(1, 2, 'beta', 'gamma', 'delta');
+// [{type: 'splice', object: &lt;arr&gt;, index: 1, removed: ['B', 'c', 'd'], addedCount: 3}]
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p><a href="https://github.com/arv/ecmascript-object-observe">Strawman proposal specification</a>.</p>
+
+<h2 id="Compatibilidade_com_Browser">Compatibilidade com Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("36")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="//stackoverflow.com/q/29269057/778272">Em qual condição a chamada Array.observe irá "adicionar" um gatilho para um evento?</a></li>
+ <li>{{jsxref("Array.unobserve()")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("Object.observe()")}} {{non-standard_inline}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/of/index.html b/files/pt-br/web/javascript/reference/global_objects/array/of/index.html
new file mode 100644
index 0000000000..d7d72259cb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/of/index.html
@@ -0,0 +1,108 @@
+---
+title: Array.of()
+slug: Web/JavaScript/Reference/Global_Objects/Array/of
+tags:
+  - Array
+  - ECMAScript6
+  - JavaScript
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/of
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Array.of()</strong></code> cria um nova instância de <code>Array</code> com um número variável de argumentos, independentemente do número ou do tipo dos argumentos.</p>
+
+<p>A diferença entre o <code><strong>Array.of()</strong></code> e o construtor de <code><strong>Array</strong></code> é no tratamento dos argumentos inteiros: <code><strong>Array.of(7)</strong></code> cria um array com um único elemento, <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">7</span></font>, enquanto <code><strong>Array(7)</strong></code> cria um array vazio de propriedade <code>length</code> igual a <code>7</code> (<strong>Nota</strong>: isso quer dizer um array com <code>7</code> espaços vazios, e não com valores do tipo {{jsxref("undefined")}}).</p>
+
+<pre>Array.of(7);       // [7]
+Array.of(1, 2, 3); // [1, 2, 3]
+
+Array(7);          // array com 7 espaços vazios
+Array(1, 2, 3);    // [1, 2, 3]
+</pre>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="syntaxbox"><code>Array.of(<var>element0</var>[, <var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>element<em>N</em></code></dt>
+ <dd>Elementos usados para criar o <code>array</code>.</dd>
+ <dt>
+ <h3 id="Valor_de_retorno">Valor de retorno</h3>
+ </dt>
+ <dd>Uma nova instância de {{jsxref("Array")}}. </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Esta função é parte do padrão ECMAScript 6 (ou ECMAScript 2015).</p>
+
+<p>Para maiores informações veja:</p>
+
+<ul>
+ <li><a href="https://gist.github.com/rwaldron/1074126"><code>Array.of</code> </a></li>
+ <li><a href="https://gist.github.com/rwaldron/1074126"><code>Array.from</code> proposal</a></li>
+ <li><a href="https://gist.github.com/rwaldron/3186576"><code>Array.of</code> polyfill</a>.</li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">Array.of(1);         // [1]
+Array.of(1, 2, 3);   // [1, 2, 3]
+Array.of(undefined); // [undefined]
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Executando o seguinte código antes de qualquer outro c[odigo criará o <code>Array.of()</code> se ele não for disponível nativamente.</p>
+
+<pre class="brush: js">if (!Array.of) {
+  Array.of = function() {
+    return Array.prototype.slice.call(arguments);
+    // Or
+    let vals = [];
+    for(let prop in arguments){
+        vals.push(arguments[prop]);
+    }
+    return vals;
+  };
+}
+</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-array.of', 'Array.of')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<div id="compat-mobile">
+<div class="hidden">
+<p>A tabela de compatibilidade nesta página é gerada por dados estruturados. Se você quiser contribuir com os dados, visite <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie uma <em>pull request</em>.</p>
+</div>
+
+<p>{{Compat("javascript.builtins.Array.of")}}</p>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Array")}}</li>
+ <li>{{jsxref("Array.from()")}}</li>
+ <li>{{jsxref("TypedArray.of()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/pop/index.html b/files/pt-br/web/javascript/reference/global_objects/array/pop/index.html
new file mode 100644
index 0000000000..6bd4c55b5e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/pop/index.html
@@ -0,0 +1,81 @@
+---
+title: Array.prototype.pop()
+slug: Web/JavaScript/Reference/Global_Objects/Array/pop
+tags:
+  - Array
+  - JavaScript
+  - Pop
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <code><strong>pop()</strong></code> remove o <strong>último</strong> elemento de um array e retorna aquele elemento.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.pop()</code></pre>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O método <code>pop</code> remove o último elemento de um array e retorna aquele valor.</p>
+
+<p>Esse método é intencionalmente genérico. Podendo ser utilizado por {{jsxref("Function.call", "call", "", 1)}} ou {{jsxref("Function.apply", "apply", "", 1)}} em objetos que implementam arrays.</p>
+
+<p>Se você chamar <code>pop()</code> em um array vazio, ele retorna o valor {{jsxref("Global_Objects/undefined", "undefined")}}.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Removing_the_last_element_of_an_array" name="Example:_Removing_the_last_element_of_an_array">Exemplo: Removendo o último elemento de um array</h3>
+
+<p>O código seguinte cria o array <code>meuPeixe </code>contendo quatro elementos e então remove seu último elemento.</p>
+
+<pre class="brush: js notranslate">var meuPeixe = ['acara-bandeira', 'palhaco', 'mandarim', 'esturjao'];
+
+console.log(meuPeixe); // ['acara-bandeira', 'palhaco', 'mandarim', 'esturjao']
+
+var meuPeixePop = meuPeixe.pop();
+
+console.log(meuPeixe); // ['acara-bandeira', 'palhaco', 'mandarim' ]
+
+console.log(meuPeixePop); // 'esturjao'</pre>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 3ª Edição</td>
+   <td>Padrão</td>
+   <td>Definição inicial. Implementado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade nos Navegadores</h2>
+
+<div>{{Compat("javascript.builtins.Array.pop")}}</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.push()")}}</li>
+ <li>{{jsxref("Array.prototype.shift()")}}</li>
+ <li>{{jsxref("Array.prototype.unshift()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html
new file mode 100644
index 0000000000..e863d9cc69
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/prototype/index.html
@@ -0,0 +1,206 @@
+---
+title: Array.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Array/prototype
+tags:
+  - Array
+  - JavaScript
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/prototype
+---
+<div>{{JSRef}}</div>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Instâncias de {{jsxref("Global_Objects/Array", "Array")}} herdam de <code>Array.prototype</code>. Como em todos os construtores, você pode mudar o  protótipo desse construtor para modificar todas as instâncias de {{jsxref("Global_Objects/Array", "Array")}}.</p>
+
+<p>Contudo, a adição de métodos não-padronizados ao objeto array pode causar problemas futuros, seja com seu próprio código, ou na <a href="https://developers.google.com/web/updates/2018/03/smooshgate">adição de novas funcionalidades ao JavaScript</a>.</p>
+
+<p>Um fato pouco conhecido: O próprio <code>Array.prototype </code>é um {{jsxref("Global_Objects/Array", "Array")}}</p>
+
+<pre class="brush: js">Array.isArray(Array.prototype); // true
+</pre>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt><code>Array.prototype.constructor</code></dt>
+ <dd>Especifica a função que cria um objeto do protótipo.<br>
+  </dd>
+ <dt>{{jsxref("Array.prototype.length")}}</dt>
+ <dd>Reflete o número de elementos em um array.</dd>
+</dl>
+
+<h2 id="Methods" name="Methods">Métodos</h2>
+
+<h3 id="Mutator_methods" name="Mutator_methods">Métodos modificadores</h3>
+
+<p>Esses métodos modificam o array:</p>
+
+<dl>
+ <dt>{{jsxref("Array.prototype.copyWithin()")}} {{experimental_inline}}</dt>
+ <dd>Copia uma sequência de elementos do array dentro do array.</dd>
+ <dt>{{jsxref("Array.prototype.fill()")}} {{experimental_inline}}</dt>
+ <dd>Preenche todos os elementos de um array com um elemento estático, começando de um índice inicial até um índice final.</dd>
+ <dt>{{jsxref("Array.prototype.pop()")}}</dt>
+ <dd>Remove e retorna o último elemento de um array.</dd>
+ <dt>{{jsxref("Array.prototype.push()")}}</dt>
+ <dd>Adiciona um ou mais elementos ao fim de um array e retorna o novo comprimeiro do array.</dd>
+ <dt>{{jsxref("Array.prototype.reverse()")}}</dt>
+ <dd>Reverte a ordem dos elementos de um array - o primeiro vira o último e o último vira o primeiro.</dd>
+ <dt>{{jsxref("Array.prototype.shift()")}}</dt>
+ <dd>Remove o primeiro elemento de um array e o retorna.</dd>
+ <dt>{{jsxref("Array.prototype.sort()")}}</dt>
+ <dd>Ordena os elementos do array em questão e retorna o array.</dd>
+ <dt>{{jsxref("Array.prototype.splice()")}}</dt>
+ <dd>Adiciona e/ou remove elementos de um array.</dd>
+ <dt>{{jsxref("Array.prototype.unshift()")}}</dt>
+ <dd>Adiciona um ou mais elementos ao início de um array e retorna o novo comprimento do array.</dd>
+</dl>
+
+<h3 id="Accessor_methods" name="Accessor_methods">Métodos de acesso</h3>
+
+<p>Esses métodos não modificam o array, mas sim retornam alguma representação dele.</p>
+
+<dl>
+ <dt>{{jsxref("Array.prototype.concat()")}}</dt>
+ <dd>Retorna um novo array formado por esse array concatenado com outro(s) array(s) e/ou valores.</dd>
+ <dt>{{jsxref("Array.prototype.contains()")}} {{experimental_inline}}</dt>
+ <dd>Verifica se o array possui cer, retornando<code>true</code> ou <code>false</code> apropriadamente.</dd>
+ <dt>{{jsxref("Array.prototype.join()")}}</dt>
+ <dd>Retorna uma string com todos os elementos do array</dd>
+ <dt>{{jsxref("Array.prototype.slice()")}}</dt>
+ <dd>Retorna um novo array com uma parte do array sobre o qual o método foi chamado</dd>
+ <dt>{{jsxref("Array.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna um array literal representando o array especificado; você pode usar esse valor para criar um novo array. Esse método sobrescreve o método {{jsxref("Object.prototype.toSource()")}}.</dd>
+ <dt>{{jsxref("Array.prototype.toString()")}}</dt>
+ <dd>Retonar uma string representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("Array.prototype.toLocaleString()")}}</dt>
+ <dd>Retonar uma string adequada ao idioma do usuário representando o array e seus elementos. Esse método sobrescreve o método {{jsxref("Object.prototype.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("Array.prototype.indexOf()")}}</dt>
+ <dd>Representa o índice da primeira ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array.</dd>
+ <dt>{{jsxref("Array.prototype.lastIndexOf()")}}</dt>
+ <dd>Representa o índice da última ocorrência de um valor especificado no array, ou -1 se o valor não estiver incluso no array</dd>
+</dl>
+
+<h3 id="Iteration_methods" name="Iteration_methods">Métodos de iteração</h3>
+
+<p>Vários métodos tomam como funções de argumento para serem chamados de volta ao processar o array. Quando esses métodos são chamados, o `<code>length` do array</code> é amostrado e qualquer elemento adicionado além deste comprimento (length)  de dentro da função (callback) não é visitado. Outras alterações para o array (Definindo o valor de ou apagando um elemento) pode afetar os resultados da operação se o método visita o elemento alterado posteriormente. Enquanto o comportamento específico destes métodos nestes casos é bem definido, não se deve confiar nisso para não confundir os outros que possoam ler seu código. Em vez disso, deve-se copiar para um novo array para modificá-lo.</p>
+
+<dl>
+ <dt>{{jsxref("Array.prototype.forEach()")}}</dt>
+ <dd>Chama a função para cada elemento no array.</dd>
+ <dt>{{jsxref("Array.prototype.entries()")}} {{experimental_inline}}</dt>
+ <dd>Retorna um novo objeto <code>Array Iterator</code> que contem o par chave/valor para cada índice no array.</dd>
+ <dt>{{jsxref("Array.prototype.every()")}}</dt>
+ <dd>Retorna true se todos elementos no array satisfizer a função de teste fornecida.</dd>
+ <dt>{{jsxref("Array.prototype.some()")}}</dt>
+ <dd>Retorna true se pelo menos um elemento no array satisfizer a função de teste fornecida.</dd>
+ <dt>{{jsxref("Array.prototype.filter()")}}</dt>
+ <dd>Cria um novo array com todos os elementos do array para qual a função de filtragem fornecida retorne true.</dd>
+ <dt>{{jsxref("Array.prototype.find()")}} {{experimental_inline}}</dt>
+ <dd>Retorna o valor encontrado no array, se um elemento no array satisfizer a funçào de teste fornecida ou  `<code>undefined` </code>se não for encontrado.</dd>
+ <dt>{{jsxref("Array.prototype.findIndex()")}} {{experimental_inline}}</dt>
+ <dd>Retorna o índice no array, se um elemento no array satisfizer a função de teste fornecida ou -1 se não for encontrado.</dd>
+ <dt>{{jsxref("Array.prototype.keys()")}} {{experimental_inline}}</dt>
+ <dd>Retorna um novo <code>Array Iterator</code> que contem a chave para cada índice no array.</dd>
+ <dt>{{jsxref("Array.prototype.map()")}}</dt>
+ <dd>Cria um novo array com os resultados da função fornecida chamada em cada elemento na array.</dd>
+ <dt>{{jsxref("Array.prototype.reduce()")}}</dt>
+ <dd>Aplica uma função contra um acumulador e cada valor do array (da esquerda para direita) para reduzi-los a um único valor.</dd>
+ <dt>{{jsxref("Array.prototype.reduceRight()")}}</dt>
+ <dd>Aplica uma função contra um acumulador e cada valor do array (da direita para esquerda) para reduzi-los a um único valor.</dd>
+ <dt>{{jsxref("Array.prototype.values()")}} {{experimental_inline}}</dt>
+ <dd>Retorna um novo objeto <code>Array Iterator</code> que contem os valores de cada índice no array.</dd>
+ <dt>{{jsxref("Array.prototype.@@iterator()", "Array.prototype[@@iterator]()")}} {{experimental_inline}}</dt>
+ <dd>Retorna um novo objeto <code>Array Iterator</code> que contem os valores de cada índice no array.</dd>
+</dl>
+
+<h3 id="Generic_methods" name="Generic_methods">Métodos genéricos</h3>
+
+<p>Vários métodos do objeto Array em Javascript foram feitos para serem aplicados genericamentes em todos os objetos que "pareçam" Arrays. Isso é, eles podem ser usados em qualquer objeto que possuam uma propriedade <code>length</code> (comprimento), e que possa ser usado a partir de propriedades numéricas (como índices no formato <code>array[5]</code>). Alguns métodos, como {{jsxref("Array.join", "join")}}, apenas lêem e as propriedades numéricas do objeto sobre o qual eles sãochamados. Outros, como {{jsxref("Array.reverse", "reverse")}}, exigem que as propriedades numéricas e <code>length </code>sejam mutáveis; sendo assim, esses métodos não podem ser chamados em objetos como {{jsxref("Global_Objects/String", "String")}}, que não permitem que nenhuma das duas propriedades sejam modificadas.</p>
+
+<h2 id="Specifications" name="Specifications">Especifiações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Padrão</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.3.1', 'Array.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype', 'Array.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Array", "Array")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/push/index.html b/files/pt-br/web/javascript/reference/global_objects/array/push/index.html
new file mode 100644
index 0000000000..7b93843b2b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/push/index.html
@@ -0,0 +1,184 @@
+---
+title: Array.prototype.push()
+slug: Web/JavaScript/Reference/Global_Objects/Array/push
+tags:
+  - Array
+  - JavaScript
+  - Push
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/push
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong>push() </strong>adiciona um ou mais elementos ao final de um array e retorna o novo comprimento desse array.</p>
+
+<pre class="brush: js">var numeros = [1, 2, 3];
+numeros.push(4);
+
+console.log(numeros); // [1, 2, 3, 4]
+
+numeros.push(5, 6, 7);
+
+console.log(numeros); // [1, 2, 3, 4, 5, 6, 7]
+</pre>
+
+<p><strong style="font-size: 2.14285714285714rem; font-weight: 700; letter-spacing: -1px; line-height: 30px;">Sintaxe</strong></p>
+
+<pre class="syntaxbox"><code><var>arr</var>.push(<var>elemento1</var>, ..., <var>elementoN</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>elemento<em>N</em></code></dt>
+ <dd>Os elementos a serem incluídos ao final do array.</dd>
+</dl>
+
+<h3 id="Returns" name="Returns">Retorno</h3>
+
+<p>O novo valor da propriedade {{jsxref("Array.length", "length")}} do objeto no qual o método foi chamado.</p>
+
+<p><strong style="font-size: 2.14285714285714rem; font-weight: 700; letter-spacing: -1px; line-height: 30px;">Descrição</strong></p>
+
+<p>O método <code style="font-style: normal;">push</code> adiciona valores a um array.</p>
+
+<p>Esse método é intencionalmente genérico. Podendo ser utilizado por {{jsxref("Function.call", "call()")}} ou {{jsxref("Function.apply", "apply()")}} em objetos que implementam arrays.  O método <span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">push </span><span style="line-height: 1.5;">depende da propriedade </span><span style="font-family: 'Courier New','Andale Mono',monospace; line-height: 1.5;">length</span><span style="line-height: 1.5;"> para determinar onde começar a inserir os valores. Caso a propriedade <code>length</code></span> não possa ser convertida em número, é utilizado 0 como índice. Isto inclui a possibilidade de <code>length </code>não existir, nesse caso, essa propriedade será criada.</p>
+
+<p>Os únicos objetos que implementam nativamente array são as {{jsxref("Global_Objects/String", "strings", "", 1)}}, porém elas não são adequadas para a aplicação desse método, pois são imutáveis.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Adding_elements_to_an_array" name="Example:_Adding_elements_to_an_array">Exemplo: Adicionando elementos a um array</h3>
+
+<p>O seguinte código cria um array <code>esportes</code> que contém dois elementos. Então adiciona dois elementos a ele. A variável <code>total</code> contém o novo comprimento do array.</p>
+
+<pre class="brush: js">var esportes = ['futebol', 'beisebol'];
+var total = esportes.push('handebol', 'natacao');
+
+console.log(esportes); // ['futebol, 'beisebol', 'handebol', 'natacao']
+console.log(total);  // 4
+</pre>
+
+<h3 id="Example:_Adding_elements_to_an_array" name="Example:_Adding_elements_to_an_array" style="line-height: 24px; font-size: 1.71428571428571rem;">Exemplo: Fusão de dois arrays</h3>
+
+<p>Este exemplo utiliza {{jsxref("Function.apply", "apply()")}} para adicionar todos os elementos de um segundo array.</p>
+
+<pre class="brush: js  language-js" style="padding: 1em 0px 1em 30px; font-size: 14px; white-space: normal; color: rgb(77, 78, 83);"><code class="language-js" style="direction: ltr; white-space: pre;"><span class="keyword token" style="color: #0077aa;">var</span> vegetais <span class="operator token" style="background: rgba(255, 255, 255, 0.498039); color: #a67f59;">=</span> <span class="punctuation token" style="color: #999999;">[</span><span class="string token" style="color: #669900;">'cenoura'</span><span class="punctuation token" style="color: #999999;">,</span> <span class="string token" style="color: #669900;">'batata'</span><span class="punctuation token" style="color: #999999;">]</span><span class="punctuation token" style="color: #999999;">;</span>
+<span class="keyword token" style="color: #0077aa;">var</span> maisVegetais <span class="operator token" style="background: rgba(255, 255, 255, 0.498039); color: #a67f59;">=</span> <span class="punctuation token" style="color: #999999;">[</span><span class="string token" style="color: #669900;">'aipo'</span><span class="punctuation token" style="color: #999999;">,</span> <span class="string token" style="color: #669900;">'beterraba'</span><span class="punctuation token" style="color: #999999;">]</span><span class="punctuation token" style="color: #999999;">;</span>
+<span class="comment token" style="color: #708090;">
+// Adiciona o segundo array no primeiro
+</span><span class="comment token" style="color: #708090;">// Equivalente a vegetais.push('aipo', 'beterraba');
+</span>Array<span class="punctuation token" style="color: #999999;">.</span>prototype<span class="punctuation token" style="color: #999999;">.</span>push<span class="punctuation token" style="color: #999999;">.</span><span class="function token" style="color: #dd4a68;">apply<span class="punctuation token" style="color: #999999;">(</span></span>vegetais<span class="punctuation token" style="color: #999999;">,</span> maisVegetais<span class="punctuation token" style="color: #999999;">)</span><span class="punctuation token" style="color: #999999;">;</span>
+
+console<span class="punctuation token" style="color: #999999;">.</span><span class="function token" style="color: #dd4a68;">log<span class="punctuation token" style="color: #999999;">(</span></span>vegetais<span class="punctuation token" style="color: #999999;">)</span><span class="punctuation token" style="color: #999999;">;</span><span class="comment token" style="color: #708090;"> // ['cenoura', 'batata', 'aipo', 'beterraba']</span></code></pre>
+
+<h3 id="Example:_Using_an_object_in_an_array-like_fashion" name="Example:_Using_an_object_in_an_array-like_fashion" style="line-height: 24px; font-size: 1.71428571428571rem;">Exemplo: Utilizando um object como um array-like</h3>
+
+<p>Como mencionado acima, <code>push</code> é intencionalmente genérico, e podemos usar isso para nossa vantagem. <code>Array.prototype.push</code> pode trabalhar em um objeto muito bem, como mostra este exemplo. Observe que não criamos um array para armazenar uma coleção de objetos. Em vez disso, armazenamos a coleção no objeto em si e usamos a chamada em <code>Array.prototype.push</code> para enganar o método e pensar que estamos lidando com um array, e ele simplesmente funciona, graças à forma como o JavaScript nos permite estabelecer o contexto de execução quando queremos.</p>
+
+<pre class="brush: js">var obj = {
+    length: 0,
+
+    addElem: function addElem(elem) {
+        // obj.length é automaticamente incrementado
+        // toda vez que um elemento for adicionado.
+        [].push.call(this, elem);
+    }
+};
+
+// Vamos adicionar alguns objetos vazios apenas para ilustrar.
+obj.addElem({});
+obj.addElem({});
+console.log(obj.length);
+// → 2
+</pre>
+
+<p>Observe que, embora <code>obj</code> não seja um array, o método <code>push</code> aumentou com sucesso a propriedade de comprimento (<code>length</code>) do <code>obj</code> como se estivéssemos lidando com um array.</p>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 3ª Edição</td>
+   <td>Padrão</td>
+   <td>Implementação inicial. Implentado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.7', 'Array.prototype.push')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.push', 'Array.prototype.push')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade em navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("1.0")}}</td>
+   <td>{{CompatGeckoDesktop("1.7")}}</td>
+   <td>{{CompatIE("5.5")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th><span style="font-family: 'Open Sans Light',sans-serif; font-size: 16px; line-height: 16px;">Característica</span></th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Móvel (Gecko)</th>
+   <th>IE M<span style="font-family: 'Open Sans Light',sans-serif; font-size: 16px; line-height: 16px;">óvel</span></th>
+   <th>Opera <span style="font-family: 'Open Sans Light',sans-serif; font-size: 16px; line-height: 16px;">Móvel</span></th>
+   <th>Safari <span style="font-family: 'Open Sans Light',sans-serif; font-size: 16px; line-height: 16px;">Móvel</span></th>
+  </tr>
+  <tr>
+   <td><span style="font-size: 12px; line-height: 18px;">Suporte básico</span></td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.pop()")}}</li>
+ <li>{{jsxref("Array.prototype.shift()")}}</li>
+ <li>{{jsxref("Array.prototype.unshift()")}}</li>
+ <li>{{jsxref("Array.prototype.concat()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html b/files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html
new file mode 100644
index 0000000000..0268b64c00
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/reduce/index.html
@@ -0,0 +1,513 @@
+---
+title: Array.prototype.reduce()
+slug: Web/JavaScript/Reference/Global_Objects/Array/Reduce
+tags:
+  - Array
+  - JavaScript
+  - Métodos
+  - Prototipo
+  - Referencia
+  - reduce()
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/Reduce
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>reduce()</strong></code> executa uma função <strong>reducer</strong> (fornecida por você) para cada elemento do array, resultando num único valor de retorno.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/array-reduce.html")}}</div>
+
+<p class="hidden">A fonte desse exemplo interativo está armazenada em um repositório do GitHub. Se você quiser contribuir com o projeto de exemplos interativos, clone https://github.com/mdn/interactive-examples e envie-nos um pull request.</p>
+
+<p>A função <strong>reducer</strong> recebe quatro parâmetros:</p>
+
+<ol>
+ <li>Acumulador (<code>acc</code>)</li>
+ <li>Valor Atual (<code>cur</code>)</li>
+ <li>Index Atual (<code>idx</code>)</li>
+ <li>Array original (<code>src</code>)</li>
+</ol>
+
+<p>O valor de retorno da sua função <strong>reducer</strong> é atribuída ao acumulador. O acumulador, com seu valor atualizado, é repassado para cada iteração subsequente pelo array, que por fim, se tornará o valor resultante, único, final.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="brush: js notranslate"><code><var>array</var>.reduce(<var>callback( acumulador, valorAtual</var>[, index[, array]] )[, <var>valorInicial</var>]))</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função que é executada em cada valor no array (exceto no primeiro, se nenhum <font face="Consolas, Liberation Mono, Courier, monospace"><code>valorInicial</code></font> for passado); recebe quatro argumentos:</dd>
+</dl>
+
+<p><strong><font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font></strong></p>
+
+<p>Opcional. O índice do elemento atual que está sendo processado no array. Começa a partir do index <code>0</code> se um <font face="Consolas, Liberation Mono, Courier, monospace"><code>valorInicial</code> </font>for fornecido. Do contrário, começa do index <code>1</code>.</p>
+
+<dl>
+ <dt><code>valorInicial</code></dt>
+ <dd>Opcional. Valor a ser usado como o primeiro argumento da primeira chamada da função <code>callback</code>. Se nenhum <code>valorInicial</code> é fornecido, o primeiro elemento do array será usado como o valor inicial do <font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font> e o <code>valorAtual</code> não será lido. Chamar <code>reduce()</code> em uma array vazia sem valor inicial retornará um erro.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O valor que resulta da redução.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O método <code>reduce()</code> executa a função de <code>callback</code> uma vez para cada elemento presente no array, excluindo furos (valores indefinidos), recebendo quatro argumentos:</p>
+
+<ol>
+ <li><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);"><em>acumulador</em></span></font> - valor inicial (ou o valor do callback anterior),</li>
+ <li><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);"><em>valorAtual</em></span></font> - o valor do elemento atual</li>
+ <li><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);"><em>index</em></span></font> - o índice atual e</li>
+ <li><code><var>array</var></code> - o array onde a iteração está ocorrendo.</li>
+</ol>
+
+<p>A primeira vez que o callback é chamado, o<font face="Consolas, Liberation Mono, Courier, monospace"> <code>acumulador</code> e o <code>valorAtual</code> </font>podem ter um de dois valores possíveis<font face="Consolas, Liberation Mono, Courier, monospace">. </font>Se o <code><font face="Consolas, Liberation Mono, Courier, monospace">valorInicial</font></code><font face="Consolas, Liberation Mono, Courier, monospace"> </font>tiver<font face="Consolas, Liberation Mono, Courier, monospace"> </font>sido fornecido na chamada à função <font face="Consolas, Liberation Mono, Courier, monospace"><code>reduce()</code></font>, então o <font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font> será igual ao <code>valorInicial</code> e o <font face="consolas, Liberation Mono, courier, monospace"><code>valorAtual</code> </font>será igual ao primeiro valor no array. Caso nenhum <code>valorInicial</code> seja fornecido, <font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font> será igual ao primeiro valor no array, e <code>valorAtual</code> será igual ao segundo.</p>
+
+<div class="note">
+<p><strong>Nota</strong>: Se o <code>valorInicial</code> não tiver sido passado como argumento, então <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">reduce()</span></font> executará o callback da função começando a partir do índice 1 (<font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">index 1</span></font>), pulando o primeiro índice (<code>index 0</code>). Se o <code>valorInicial</code> for passado como argumento, a função irá começar no <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">index 0</span></font>.</p>
+</div>
+
+<p>Se a array estiver vazia e o <code>valorInicial</code> não tiver sido informado, uma exceção do tipo {{jsxref("Global_Objects/TypeError", "TypeError")}} será lançada.</p>
+
+<p>Se a array possuir somente um elemento (independente da posição) e o <code>valorInicial</code> não tiver sido fornecido, ou se <code>valorInicial</code> for fornecido, mas a array estiver vazia, o valor será retornado sem que a função de <code>callback</code> seja chamada.</p>
+
+<p>É mais seguro provir um <code>valorInicial</code>, porque existem até <em>quatro</em> possíveis saídas sem o <code>valorInicial</code>, como mostrado no exemplo:</p>
+
+<pre class="brush: js notranslate">var maxCallback = ( acc, cur ) =&gt; Math.max( acc.x, cur.x );
+var maxCallback2 = ( max, cur ) =&gt; Math.max( max, cur );
+
+// reduce() sem valores iniciais
+[ { x: 22 }, { x: 42 } ].reduce( maxCallback ); // 42
+[ { x: 22 }            ].reduce( maxCallback ); // { x: 22 }
+[                      ].reduce( maxCallback ); // TypeError
+
+// map/reduce; melhor solução, funciona para vetores vazios e tambem para vetores grandes
+[ { x: 22 }, { x: 42 } ].map( el =&gt; el.x )
+                        .reduce( maxCallback2, -Infinity );</pre>
+
+<h3 id="Como_funciona_o_reduce">Como funciona o reduce()</h3>
+
+<p>Suponha que o seguinte uso de <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">reduce()</span></font> tenha ocorrido:</p>
+
+<pre class="brush: js notranslate">[0, 1, 2, 3, 4].reduce(function(a<font face="Consolas, Liberation Mono, Courier, monospace"><code>cumulador</code></font>, valorAtual, index, array) {
+  return a<font face="Consolas, Liberation Mono, Courier, monospace"><code>cumulador</code></font> + valorAtual;
+});
+// 10</pre>
+
+<p>O callback será invocado quatro vezes, com os argumentos e valores em cada chamada  sendo:</p>
+
+<table style="width: 100%;">
+ <thead>
+  <tr>
+   <th scope="col"></th>
+   <th scope="col"><font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font></th>
+   <th scope="col"><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">valorAtual</span></font></th>
+   <th scope="col"><font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">index</span></font></th>
+   <th scope="col"><code>array</code></th>
+   <th scope="col"><strong>valor de retorno</strong></th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <th scope="row">primeira chamada</th>
+   <td><code>0</code></td>
+   <td><code>1</code></td>
+   <td><code>1</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>1</code></td>
+  </tr>
+  <tr>
+   <th scope="row">segunda chamada</th>
+   <td><code>1</code></td>
+   <td><code>2</code></td>
+   <td><code>2</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>3</code></td>
+  </tr>
+  <tr>
+   <th scope="row">terceira chamada</th>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>6</code></td>
+  </tr>
+  <tr>
+   <th scope="row">quarta chamada</th>
+   <td><code>6</code></td>
+   <td><code>4</code></td>
+   <td><code>4</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>10</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>O valor retornado pelo <code>reduce</code> será o da última chamada à callback <code>(10)</code>.</p>
+
+<p>Você também pode usar uma {{jsxref("Functions/Arrow_functions", "Arrow Function","",1)}} em vez de uma função completa. O código abaixo produz a mesma saída que o código do bloco acima:</p>
+
+<pre class="brush: js line-numbers  language-js notranslate">[0, 1, 2, 3, 4].reduce( (accum, curr) =&gt; accum + curr );</pre>
+
+<p>Se você informar um <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">valorInicial</span></font> como o segundo argumento de reduce, o resultado será:</p>
+
+<pre class="brush: js notranslate">[0, 1, 2, 3, 4].reduce(function(acumulador, valorAtual, indice, array) {
+  return acumulador + valorAtual;
+}, 10);
+
+// 20</pre>
+
+<table style="width: 100%;">
+ <thead>
+  <tr>
+   <th scope="col"><code>callback</code></th>
+   <th scope="col"><font face="Consolas, Liberation Mono, Courier, monospace"><code>acumulador</code></font></th>
+   <th scope="col"><code>valorAtual</code></th>
+   <th scope="col"><code>index</code></th>
+   <th scope="col"><code>array</code></th>
+   <th scope="col"><code>valor de retorno</code></th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <th scope="row">primeira chamada</th>
+   <td><code>10</code></td>
+   <td><code>0</code></td>
+   <td><code>0</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>10</code></td>
+  </tr>
+  <tr>
+   <th scope="row">segunda chamada</th>
+   <td><code>10</code></td>
+   <td><code>1</code></td>
+   <td><code>1</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>11</code></td>
+  </tr>
+  <tr>
+   <th scope="row">terceira chamada</th>
+   <td><code>11</code></td>
+   <td><code>2</code></td>
+   <td><code>2</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>13</code></td>
+  </tr>
+  <tr>
+   <th scope="row">quarta chamada</th>
+   <td><code>13</code></td>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>16</code></td>
+  </tr>
+  <tr>
+   <th scope="row">quinta chamada</th>
+   <td><code>16</code></td>
+   <td><code>4</code></td>
+   <td><code>4</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>20</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>O retorno da última chamada <code>20</code>,é retornado como resultado da função <code>reduce()</code>.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Sum_up_all_values_within_an_array" name="Example:_Sum_up_all_values_within_an_array">Soma todos os valores de uma array</h3>
+
+<pre class="brush: js notranslate">let total = [0, 1, 2, 3].reduce(function(acumulador, valorAtual) {
+   return acumulador + valorAtual;
+ }, 0)
+// retorna 6</pre>
+
+<p>outra alternativa é usar uma arrow function:</p>
+
+<pre class="notranslate"><code>var total = [ 0, 1, 2, 3 ].reduce(
+  ( acumulador, valorAtual ) =&gt; acumulador + valorAtual,
+  0
+);</code></pre>
+
+<h3 id="Soma_de_valores_de_um_objeto_de_um_array">Soma de valores de um objeto de um array</h3>
+
+<p>Para resumir os valores contidos em um array, você <strong>deve </strong>fornecer um <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">valorInicial</span></font>, para que cada item passe por sua função.</p>
+
+<pre class="notranslate"><code>var valorInicial = 0;
+var soma = [{x: 1}, {x: 2}, {x: 3}].reduce(function (acumulador, valorAtual) {
+    return acumulador + valorAtual.x;
+}, valorInicial)
+
+console.log(soma) // retorna 6</code></pre>
+
+<p>Utilizando uma arrow function:</p>
+
+<pre class="notranslate"><code>var valorInicial = 0;
+var soma = [{x: 1}, {x: 2}, {x: 3}].reduce(
+    (acumulador , valorAtual) =&gt; acumulador + valorAtual.x
+    , valorInicial
+);
+
+console.log(soma) // retorna 6</code>
+</pre>
+
+<h3 id="Example_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Redução de um array de arrays</h3>
+
+<pre class="notranslate">let reduzido = [[0, 1], [2, 3], [4, 5]].reduce(
+  function(acumulador, valorAtual) {
+    return acumulador.concat(valorAtual)
+  },
+  []
+)
+// reduzido é [0, 1, 2, 3, 4, 5]</pre>
+
+<p>Utilizando uma arrow function:</p>
+
+<pre class="notranslate"><code>let reduzido = [[0, 1], [2, 3], [4, 5]].reduce(
+  ( acumulador, valorAtual ) =&gt; acumulador.concat(valorAtual),
+  []
+);</code></pre>
+
+<h3 id="Contando_valores_iguais_em_um_objeto">Contando valores iguais em um objeto</h3>
+
+<pre class="brush: js line-numbers  language-js notranslate"><code class="language-js">let nomes = ['Alice', 'Bob', 'Tiff', 'Bruce', 'Alice'];
+
+let quantidadeNomes = nomes.reduce(function (todosNomes, nome) {
+  if (nome in todosNomes) {
+    todosNomes[nome]++;
+  }
+  else {
+    todosNomes[nome] = 1;
+  }
+  return todosNomes;
+}, {});
+// quantidade de nomes:
+// { 'Alice': 2, 'Bob': 1, 'Tiff': 1, 'Bruce': 1 }</code>
+</pre>
+
+<h3 id="Agrupando_objetos_por_uma_propriedade">Agrupando objetos por uma propriedade</h3>
+
+<pre class="notranslate"><code>let pessoas = [
+  { nome: 'Alice', idade: 21 },
+  { nome: 'Max', idade: 20 },
+  { nome: 'Jane', idade: 20 }
+];
+
+function agruparPor(objetoArray, propriedade) {
+  return objetoArray.reduce(function (acc, obj) {
+    let key = obj[propriedade];
+    if (!acc[key]) {
+      acc[key] = [];
+    }
+    acc[key].push(obj);
+    return acc;
+  }, {});
+}
+
+let grupodePessoas = agruparPor(pessoas, 'idade');
+// grupodePessoas é:
+// {
+//   20: [
+//     { nome: 'Max', idade: 20 },
+//     { nome: 'Jane', idade: 20 }
+//   ],
+//   21: [{ nome: 'Alice', idade: 21 }]
+// }</code></pre>
+
+<h3 id="Juntando_arrays_contidos_num_array_de_objetos_usando_o_operador_spread_e_o_valorInicial">Juntando arrays contidos num array de objetos usando o operador spread e o <code>valorInicial</code></h3>
+
+<pre class="brush: js line-numbers  language-js notranslate"><code class="language-js">// friends - um array de objetos
+// onde o campo "books" é a lista de livros favoritos
+var friends = [{
+  name: 'Anna',
+  books: ['Bible', 'Harry Potter'],
+  age: 21
+}, {
+  name: 'Bob',
+  books: ['War and peace', 'Romeo and Juliet'],
+  age: 26
+}, {
+  name: 'Alice',
+  books: ['The Lord of the Rings', 'The Shining'],
+  age: 18
+}];
+
+// allbooks - lista que contém todos os livros de friends +
+// lista adicional contida em valorInicial
+var allbooks = friends.reduce(function(prev, curr) {
+  return [...prev, ...curr.books];
+}, ['Alphabet']);
+
+// allbooks = [
+//   'Alphabet', 'Bible', 'Harry Potter', 'War and peace',
+//   'Romeo and Juliet', 'The Lord of the Rings',
+//   'The Shining'
+// ]</code></pre>
+
+<h3 id="Removendo_itens_duplicados_num_array">Removendo itens duplicados num array</h3>
+
+<div class="blockIndicator note">
+<p><strong>Nota:</strong> Se você estiver usando um ambiente compatível com {{jsxref("Set")}} and {{jsxref("Array.from()")}}, você pode usar <code>let orderedArray = Array.from(new Set(myArray))</code> para obter um array em que os itens duplicados tenham sido removidos.</p>
+</div>
+
+<pre class="brush: js line-numbers  language-js notranslate"><code class="language-js">let arr = [1, 2, 1, 2, 3, 5, 4, 5, 3, 4, 4, 4, 4];
+let result = arr.sort().reduce((init, current) =&gt; {
+    if (init.length === 0 || init[init.length - 1] !== current) {
+        init.push(current);
+    }
+    return init;
+}, []);
+console.log(result); //[1,2,3,4,5]</code>
+</pre>
+
+<h3 id="Substituindo_.filter.map_por_.reduce">Substituindo .filter().map() por .reduce()</h3>
+
+<p>Usar {{jsxref("Array.filter()")}} seguido por {{jsxref("Array.map()")}} faz com que o array seja percorrido duas vezes. Você pode obter o mesmo resultado percorrendo o array apenas uma vez com {{jsxref("Array.reduce()")}}, o que é, portanto, mais eficiente. (Se você gosta de for loops, você pode usar filter e map percorrendo o array apenas uma vez com {{jsxref("Array.forEach()")}}).</p>
+
+<pre class="notranslate">const numbers = [-5, 6, 2, 0,];
+
+const doubledPositiveNumbers = numbers.reduce((accumulator, currentValue) =&gt; {
+  if (currentValue &gt; 0) {
+    const doubled = currentValue * 2;
+    accumulator.push(doubled);
+  }
+  return accumulator;
+}, []);
+
+console.log(doubledPositiveNumbers); // [12, 4]</pre>
+
+<h3 id="Rodando_promises_em_sequência">Rodando promises em sequência</h3>
+
+<pre class="brush: js line-numbers  language-js notranslate"><code class="language-js">/**
+ * Roda promises de um promise array de uma maneira encadeada
+ *
+ * @param {array} arr - promise arr
+ * @return {Object} promise object
+ */
+function runPromiseInSequense(arr) {
+  return arr.reduce((promiseChain, currentPromise) =&gt; {
+    return promiseChain.then((chainedResult) =&gt; {
+      return currentPromise(chainedResult)
+        .then((res) =&gt; res)
+    })
+  }, Promise.resolve());
+}
+
+// promise function 1
+function p1() {
+  return new Promise((resolve, reject) =&gt; {
+    resolve(5);
+  });
+}
+
+// promise function 2
+function p2(a) {
+  return new Promise((resolve, reject) =&gt; {
+    resolve(a * 2);
+  });
+}
+
+// promise function 3
+function p3(a) {
+  return new Promise((resolve, reject) =&gt; {
+    resolve(a * 3);
+  });
+}
+
+const promiseArr = [p1, p2, p3];
+runPromiseInSequense(promiseArr)
+  .then((res) =&gt; {
+    console.log(res);   // 30
+  });</code></pre>
+
+<h3 id="Escrever_map_usando_reduce">Escrever map usando reduce</h3>
+
+<pre class="notranslate">if (!Array.prototype.mapUsingReduce) {
+  Array.prototype.mapUsingReduce = function(callback, thisArg) {
+    return this.reduce(function(mappedArray, currentValue, index, array) {
+      mappedArray[index] = callback.call(thisArg, currentValue, index, array)
+      return mappedArray
+    }, [])
+  }
+}
+
+[1, 2, , 3].mapUsingReduce(
+  (currentValue, index, array) =&gt; currentValue + index + array.length
+) // [5, 7, , 10]</pre>
+
+<h2 id="Polyfill" name="Polyfill">Polyfill</h2>
+
+<p><code>Array.prototype.reduce</code> foi adicionado ao padrão ECMA-262  na quinta edição; e portanto, pode não estar presente em todas as implementações do padrão. Você pode contornar isso inserindo o código a seguir no início de seus scripts, permitindo o uso do <code>reduce()</code> em implementações que não possuem suporte nativo a ele.</p>
+
+<pre class="brush: js notranslate">// Etapas de produção para o ECMA-262, Edition 5, 15.4.4.21
+// Referencia: http://es5.github.io/#x15.4.4.21
+if (!Array.prototype.reduce) {
+  Array.prototype.reduce = function(callback /*, valorInicial*/) {
+    'use strict';
+    if (this == null) {
+      throw new TypeError('Array.prototype.reduce chamado é nulo (null) ou indefinido (undefined)');
+    }
+    if (typeof callback !== 'function') {
+      throw new TypeError(callback + ' não é uma função')
+    }
+    var t = Object(this), len = t.length &gt;&gt;&gt; 0, k = 0, value;
+    if (arguments.length == 2) {
+      value = arguments[1];
+    } else {
+      while (k &lt; len &amp;&amp; !(k in t)) {
+        k++;
+      }
+      if (k &gt;= len) {
+        throw new TypeError('Reduce possui um array vazio sem um valor inicial');
+      }
+      value = t[k++];
+    }
+    for (; k &lt; len; k++) {
+      if (k in t) {
+        value = callback(value, t[k], k, t);
+      }
+    }
+    return value;
+  };
+}
+</pre>
+
+<h2 id="Specifications" name="Specifications">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('ES5.1', '#sec-15.4.4.21', 'Array.prototype.reduce')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>
+    <p>Definição inicial. Implemetada no JavaScript 1.8.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.reduce', 'Array.prototype.reduce')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Navegadores compatíveis</h2>
+
+<p>A tabela de compatibilidade encontrada nesta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, consulte : <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um "pull request".</p>
+
+<div>{{Compat("javascript.builtins.Array.reduce")}}</div>
+
+<h2 id="See_also" name="See_also">Leia também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.reduceRight()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html b/files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html
new file mode 100644
index 0000000000..67ad0a2bdd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/reduceright/index.html
@@ -0,0 +1,258 @@
+---
+title: Array.prototype.reduceRight()
+slug: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/ReduceRight
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O método <code><strong>reduceRight()</strong></code> aplica à uma função um acumulador e cada valor do array (da direita para esquerda) é reduzido para um valor único.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.reduceRight(<var>callback</var>[, <var>initialValue</var>])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função para executar em cada valor do array, recebendo quatro argumentos:
+ <dl>
+  <dt><code>previousValue</code></dt>
+  <dd>O valor anteriormente retornado na ultima invocação do callback, ou o <code>initialValue</code>, se este for o recebido. (Ver abaixo.)</dd>
+  <dt><code>currentValue</code></dt>
+  <dd>O valor atualmente sendo processado no array.</dd>
+  <dt><code>index</code></dt>
+  <dd>O índice do valor atualmente sendo processado no array.</dd>
+  <dt><code>array</code></dt>
+  <dd>O array que foi chamado para ser reduzido.</dd>
+ </dl>
+ </dd>
+ <dt><code>initialValue</code></dt>
+ <dd>Opcional. Objeto para ser usado como argumento inicial da primeria chamada do callback.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><code>reduceRight</code> executa a função callback uma vez para cada elemento presente no array, excluindo buracos no array, recebendo quatro argumentos: o valor inicial (ou o valor da chamada anterior do callback), o valor do elemento atual, o índice do elemento atual, e o array onde a operação está acontecendo.</p>
+
+<p>A chamada ao callback reduceRight <font face="Consolas, Liberation Mono, Courier, monospace">irá parecer com uma chamada assim</font>:</p>
+
+<pre class="brush: js">array.reduceRight(function(previousValue, currentValue, index, array) {
+  // ...
+});
+</pre>
+
+<p>A primeira vez que a função é chamada, o <code>previousValue</code> e o <code>currentValue</code> podem ser um de dois valores. Se um <code>initialValue</code> foi recebido na chamada do <code>reduceRight</code>, então o <code>previousValue</code> sera iqual ao <code>initialValue</code> e o <code>currentValue</code> será igual ao ultimo valor no array. Se o <code>initialValue</code> não foi recebido, então o <code>previousValue será igual ao ultimo valor no array e o </code><code>currentValue</code> será igual ao penultimo valor no array.</p>
+
+<p>Se o array é vazio e nenhum <code>initialValue </code>foi recebido, {{jsxref("Global_Objects/TypeError", "TypeError")}} será lançado. Se o array somente tem um elemento (independentemente da posição dele) e o <code>initialValue </code>não foi recebido, ou se o <code>initialValue</code> foi recebido mas o array é vazio, o valor em si será retornado sem chamar o <code>callback</code>.</p>
+
+<p>Alguns exemplos de execuções da função e como será parecida a chamada:</p>
+
+<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+});
+</pre>
+
+<p>O callback será invocado quatro vezes, com os argumentos e valores de retornos em cada chamada será como o seguinte:</p>
+
+<table style="width: 100%;">
+ <thead>
+  <tr>
+   <th scope="col"></th>
+   <th scope="col"><code>previousValue</code></th>
+   <th scope="col"><code>currentValue</code></th>
+   <th scope="col"><code>index</code></th>
+   <th scope="col"><code>array</code></th>
+   <th scope="col">return value</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <th scope="row">Primeira chamada</th>
+   <td><code>4</code></td>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>7</code></td>
+  </tr>
+  <tr>
+   <th scope="row">Segunda chamada</th>
+   <td><code>7</code></td>
+   <td><code>2</code></td>
+   <td><code>2</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>9</code></td>
+  </tr>
+  <tr>
+   <th scope="row">Terceira chamada</th>
+   <td><code>9</code></td>
+   <td><code>1</code></td>
+   <td><code>1</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>10</code></td>
+  </tr>
+  <tr>
+   <th scope="row">Quarta chamada</th>
+   <td><code>10</code></td>
+   <td><code>0</code></td>
+   <td><code>0</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>10</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>O valor retornado pelo <code>reduceRight</code> será o valor retornado pela ultima chamada ao callback(<code>10</code>).</p>
+
+<p>E se você também passou um <code>initialValue</code>, o resultado irá ser como a seguir:</p>
+
+<pre class="brush: js">[0, 1, 2, 3, 4].reduceRight(function(previousValue, currentValue, index, array) {
+  return previousValue + currentValue;
+}, 10);
+</pre>
+
+<table style="width: 100%;">
+ <thead>
+  <tr>
+   <th scope="col"></th>
+   <th scope="col"><code>previousValue</code></th>
+   <th scope="col"><code>currentValue</code></th>
+   <th scope="col"><code>index</code></th>
+   <th scope="col"><code>array</code></th>
+   <th scope="col">return value</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <th scope="row">Primeira chamada</th>
+   <td><code>10</code></td>
+   <td><code>4</code></td>
+   <td><code>4</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>14</code></td>
+  </tr>
+  <tr>
+   <th scope="row">Segunda chamada</th>
+   <td><code>14</code></td>
+   <td><code>3</code></td>
+   <td><code>3</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>17</code></td>
+  </tr>
+  <tr>
+   <th scope="row">Terceira chamada</th>
+   <td><code>17</code></td>
+   <td><code>2</code></td>
+   <td><code>2</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>19</code></td>
+  </tr>
+  <tr>
+   <th scope="row">Quarta chamada</th>
+   <td><code>19</code></td>
+   <td><code>1</code></td>
+   <td><code>1</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>20</code></td>
+  </tr>
+  <tr>
+   <th scope="row">Quinta chamada</th>
+   <td><code>20</code></td>
+   <td><code>0</code></td>
+   <td><code>0</code></td>
+   <td><code>[0, 1, 2, 3, 4]</code></td>
+   <td><code>20</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p>O valor retornado pelo <code>reduceRight</code> desta vez será, obviamente, <code>20</code>.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Sum_up_all_values_within_an_array" name="Example:_Sum_up_all_values_within_an_array">Exemplo: Somando todos os valores presente em um array</h3>
+
+<pre class="brush: js">var total = [0, 1, 2, 3].reduceRight(function(a, b) {
+  return a + b;
+});
+// total == 6
+</pre>
+
+<h3 id="Example_Flatten_an_array_of_arrays" name="Example:_Flatten_an_array_of_arrays">Exemplo: Juntando um array de arrays</h3>
+
+<pre class="brush: js">var flattened = [[0, 1], [2, 3], [4, 5]].reduceRight(function(a, b) {
+    return a.concat(b);
+}, []);
+// flattened is [4, 5, 2, 3, 0, 1]
+</pre>
+
+<h2 id="Polyfill" name="Polyfill">Polyfill</h2>
+
+<p><code>reduceRight</code> foi adicionado no padrão ECMA-262 em sua Quinta edição; sendo assim pode não estar presente em todas as implementações deste padrão. Você pode contornar isso adicionando o seguinte codigo ao inicio do seu script, adicionando a possibilidade de uso do <code>reduceRight</code> em implementações que não o suportam nativamente.</p>
+
+<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.22
+// Reference: http://es5.github.io/#x15.4.4.22
+if ('function' !== typeof Array.prototype.reduceRight) {
+  Array.prototype.reduceRight = function(callback /*, initialValue*/) {
+    'use strict';
+    if (null === this || 'undefined' === typeof this) {
+      throw new TypeError('Array.prototype.reduce called on null or undefined' );
+    }
+    if ('function' !== typeof callback) {
+      throw new TypeError(callback + ' is not a function');
+    }
+    var t = Object(this), len = t.length &gt;&gt;&gt; 0, k = len - 1, value;
+    if (arguments.length &gt;= 2) {
+      value = arguments[1];
+    } else {
+      while (k &gt;= 0 &amp;&amp; !(k in t)) {
+        k--;
+      }
+      if (k &lt; 0) {
+        throw new TypeError('Reduce of empty array with no initial value');
+      }
+      value = t[k--];
+    }
+    for (; k &gt;= 0; k--) {
+      if (k in t) {
+        value = callback(value, t[k], k, t);
+      }
+    }
+    return value;
+  };
+}
+</pre>
+
+<h2 id="Specifications" name="Specifications">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('ES5.1', '#sec-15.4.4.22', 'Array.prototype.reduceRight')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.8.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.reduceright', 'Array.prototype.reduceRight')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com os navegadores</h2>
+
+<div>{{Compat("javascript.builtins.Array.reduceRight")}}</div>
+
+<h2 id="See_also" name="See_also">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.reduce()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html b/files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html
new file mode 100644
index 0000000000..ed3b3fe160
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/reverse/index.html
@@ -0,0 +1,121 @@
+---
+title: Array.prototype.reverse()
+slug: Web/JavaScript/Reference/Global_Objects/Array/reverse
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <code><strong>reverse()</strong></code> inverte os itens de um array. O primeiro elemento do array se torna o último e o último torna-se o primeiro.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.reverse()</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O método <code>reverse</code> transpõe os elementos do objeto array no mesmo lugar, mutando o array, e retornando uma referência para o mesmo.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Reversing_the_elements_in_an_array" name="Example:_Reversing_the_elements_in_an_array">Exemplo: Invertendo os elementos em um array</h3>
+
+<p>O seguinte exemplo cria um array <code>myArray</code>, contendo três elementos, em seguida inverte-o.</p>
+
+<pre class="brush: js">var myArray = ['one', 'two', 'three'];
+myArray.reverse();
+
+console.log(myArray) // ['three', 'two', 'one']
+</pre>
+
+<h2 id="Specifications" name="Specifications">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>ECMAScript 1ª Edição</td>
+   <td>Padrão</td>
+   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.8', 'Array.prototype.reverse')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("1.0")}}</td>
+   <td>{{CompatGeckoDesktop("1.7")}}</td>
+   <td>{{CompatIE("5.5")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.join()")}}</li>
+ <li>{{jsxref("Array.prototype.sort()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.reverse()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/shift/index.html b/files/pt-br/web/javascript/reference/global_objects/array/shift/index.html
new file mode 100644
index 0000000000..34aedcaa51
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/shift/index.html
@@ -0,0 +1,104 @@
+---
+title: Array.prototype.shift()
+slug: Web/JavaScript/Reference/Global_Objects/Array/shift
+tags:
+  - Array
+  - JavaScript
+  - Prototype
+  - Reference
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/shift
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O método <strong style="font-family: courier new,andale mono,monospace; line-height: 1.5;">shift()</strong><span style="line-height: 1.5;">remove o <strong>primeiro</strong> elemento de um array e retorna esse elemento. Este método muda o tamanho do array.</span><strong style="font-family: courier new,andale mono,monospace; line-height: 1.5;"> </strong></p>
+
+<p>{{EmbedInteractiveExample("pages/js/array-shift.html")}}</p>
+
+<div class="hidden">
+<p>O código deste exemplo interativo está salvo em um repositório do GitHub. Se você quiser contribuir com o projeto de exemplos interativos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie-nos um pull request.</p>
+</div>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.shift()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O elemento removido do array; {{jsxref("undefined")}} se o array estiver vazio.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O método shift remove o elemento de índice zero, diminui em 1 os indices dos demais valores e retorna o valor removido. Se a propriedade {{jsxref("Array.length", "length")}} for 0, então {{jsxref("undefined")}} é retornado.</p>
+
+<p><code>shift</code> é intencionalmente genérico; esse método pode ser {{jsxref("Function.call", "chamado", "", 1)}} ou {{jsxref("Function.apply", "aplicado", "", 1)}} para objetos parecidos com arrays. Objetos que não contém a propriedade <code>length </code>representando o tamanho de uma série consecutiva, começando em zero, podem não se comportar de maneira correta.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Removing_an_element_from_an_array" name="Example:_Removing_an_element_from_an_array">Removendo um elemento de array</h3>
+
+<p>O código a seguir mostra o array <code>minhaLista</code> antes e depois de remover seu primeiro elemento. Ele também mostra o elemento removido.</p>
+
+<pre class="brush: js notranslate">var minhaLista = ['anjo', 'casa', 'mandarim', 'medico'];
+
+console.log('minhaLista antes: ' + minhaLista);
+// minhaList antes: ['anjo', 'casa', 'mandarim', 'medico']
+var shifted = minhaLista.shift();
+
+console.log('minhaLista depois: ' + minhaLista);
+// minhaList depois: ['casa', 'mandarim', 'medico']
+console.log('Elemento removido: ' + shifted);
+// Elemento removido: anjo
+</pre>
+
+<h3 id="Example_Removing_an_element_from_an_array" name="Example:_Removing_an_element_from_an_array">Usando o método shift() dentro de um loop de while</h3>
+
+<p>O médodo shift() é frequentemente usado como condição dentro de um loop de while. No exemplo a seguir, cada iteração removerá o elemento seguinte do array, até que ele esteja vazio:</p>
+
+<pre class="brush: js notranslate">var nomes = ["André", "Eduardo", "Paulo", "Cris", "João"];
+while( (i = nomes.shift()) !== undefined ) {
+    console.log(i);
+}
+// André Eduardo Paulo Cris João</pre>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 3rd Edition</td>
+   <td>Standard</td>
+   <td>Implementação inicial. Implementado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.9', 'Array.prototype.shift')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.shift', 'Array.prototype.shift')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade de Browser</h2>
+
+<div>{{Compat("javascript.builtins.Array.shift")}}</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.push()")}}</li>
+ <li>{{jsxref("Array.prototype.pop()")}}</li>
+ <li>{{jsxref("Array.prototype.unshift()")}}</li>
+ <li>{{jsxref("Array.prototype.concat()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/slice/index.html b/files/pt-br/web/javascript/reference/global_objects/array/slice/index.html
new file mode 100644
index 0000000000..daff58f51f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/slice/index.html
@@ -0,0 +1,224 @@
+---
+title: Array.prototype.slice()
+slug: Web/JavaScript/Reference/Global_Objects/Array/slice
+tags:
+  - Array
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>slice()</strong></code> retorna uma cópia de parte de um array a partir de um subarray criado entre as posições <code>início</code> e <code>fim</code> (<font face="consolas, Liberation Mono, courier, monospace"><span>fim</span></font> não é necessário) de um array original. O Array original não é modificado.</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.slice([<var>início</var>[,<em>fim</em>]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>início</code> {{optional_inline}}</dt>
+ <dd>Índice baseado em zero no qual se inicia a extração.</dd>
+ <dd>Como um índice negativo, <code>início</code> indica um deslocamento em relação ao fim da sequência. <code>slice(-2)</code> extrai os dois últimos elementos do array.</dd>
+ <dd>Se <font face="consolas, Liberation Mono, courier, monospace"><span>início</span></font> for omitido, <code>slice</code> inicia a partir do índice <font face="Consolas, Liberation Mono, Courier, monospace">0</font>.</dd>
+ <dd>Se <font face="consolas, Liberation Mono, courier, monospace"><span>início</span></font> for maior que o comprimento do array, é retornado um array vazio.</dd>
+ <dt><code>fim</code> {{optional_inline}}</dt>
+ <dd>Índice baseado em zero o qual é o final da extração. <code>slice</code> extrai até, não incluindo, <code>fim</code>.</dd>
+ <dd><code>slice(1,4)</code> extrai do segundo até o quarto elemento (elementos de índice 1, 2 e 3).</dd>
+ <dd>Como índice negativo, <code>fim</code> indica um deslocamento em relação ao fim do array. <code>slice(2,-1)</code> extrai o terceiro elemento através do segundo-para-o-último elemento no array.</dd>
+ <dd>Se <code>fim</code> for omitido ou for maior que o tamanho do array, <code>slice</code> considerará o último elemento do array como sendo o <code>fim </code>(<code>arr.length</code>)<code>.</code></dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um novo array contendo os elementos extraídos.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>slice</code> não altera o array original. Retorna uma cópia de elementos do array original. Elementos do array original são copiados para o array retornado da seguinte maneira:</p>
+
+<ul>
+ <li>Para referências de objeto (e não o objeto real), <code>slice</code> copia referencias de objeto em um novo array. Ambos, o original e o novo array referem-se ao mesmo objeto. Se um objeto referenciado é alterado, as alterações são visiveis em ambos, no novo array e no array original.</li>
+ <li>Para strings e números (não objetos {{jsxref("String")}} e {{jsxref("Number")}}), <code>slice</code> copia strings e números em um novo array. Alterações na string ou número em um array não afetam o outro array.</li>
+</ul>
+
+<p>Se um novo elemento é adicionado a qualquer array, o outro não é afetado.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Retorna_uma_parte_de_um_array_existente">Retorna uma parte de um array existente</h3>
+
+<pre class="brush: js notranslate">// Exemplo para extrair 'Laranja' e 'Limao' do array frutas
+var frutas = ['Banana', 'Laranja', 'Limao', 'Maçã', 'Manga'];
+var citricos = frutas.slice(1, 3);
+
+// citricos contem ['Laranja','Limao']
+</pre>
+
+<h3 id="Usando_slice">Usando <code>slice</code></h3>
+
+<p>No exemplo seguinte, <code>slice</code> cria um novo array, <code>novoCarro</code>, do original <code>meuCarro</code>. Ambos incluem uma referência ao objeto,  <code>meuHonda</code>. Quando a cor de <code>meuHonda</code> é alterada para  roxo, ambos os arrays sofrem alteração.</p>
+
+<pre class="brush: js notranslate">// Usando slice para criar novoCarro a partir de meuCarro.
+var meuHonda = { cor: 'vermelho', rodas: 4, motor: { cilindros: 4, tamanho: 2.2 } };
+var meuCarro = [meuHonda, 2, 'perfeitas condições', 'comprado em 1997'];
+var novoCarro = meuCarro.slice(0, 2);
+
+// Exibe os valores de meuCarro, novoCarro, e a cor de meuHonda
+//  referenciado de ambos arrays.
+console.log('meuCarro = ' + meuCarro.toSource());
+console.log('novoCarro = ' + novoCarro.toSource());
+console.log('meuCarro[0].cor = ' + meuCarro[0].cor);
+console.log('novoCarro[0].cor = ' + novoCarro[0].cor);
+
+// Altera a cor de meuHonda.
+meuHonda.cor= 'roxo';
+console.log('A nova cor do meu Honda é ' + meuHonda.cor);
+
+// Exibe a cor de meuHonda referenciado de ambos arrays.
+console.log('meuCarro[0].cor = ' + meuCarro[0].cor);
+console.log('novoCarro[0].cor = ' + novoCarro[0].cor);
+</pre>
+
+<p>Esse script escreve:</p>
+
+<pre class="brush: js notranslate">meuCarro = [{cor:'vermelho', rodas:4, motor:{cilindros:4, tamanho:2.2}}, 2,'perfeitas condições', 'comprado em 1997']
+novoCarro = [{cor:'vermelho', rodas:4, motor:{cilindros:4, tamanho:2.2}},2]
+meuCarro[0].cor = vermelho
+novoCarro[0].cor = vermelho
+A nova cor do meu Honda é roxo
+meuCarro[0].cor = roxo
+novoCarro[0].cor = roxo
+</pre>
+
+<h2 id="Objetos_Array-like">Objetos Array-like</h2>
+
+<p>O método <code>slice</code> pode também ser chamado para converter objetos ou coleções Array-like em um novo Array. Você só precisa encadear o método no Array. Os {{jsxref("Functions/arguments", "arguments")}} dentro de uma função são um exemplo de 'objeto array-like'.</p>
+
+<pre class="brush: js notranslate">function list() {
+  return Array.prototype.slice.call(arguments);
+}
+
+var list1 = list(1, 2, 3); // [1, 2, 3]
+</pre>
+
+<p>Ligações  podem ser feitas com a função .<code>call</code> de {{jsxref("Function.prototype")}} and it can also be reduced using <code>[].slice.call(arguments)</code> ao invés de <code>Array.prototype.slice.call</code>. De qualquer forma, ela pode ser simplificada com {{jsxref("Function.prototype.bind", "bind")}}.</p>
+
+<pre class="brush: js notranslate">var unboundSlice = Array.prototype.slice;
+var slice = Function.prototype.call.bind(unboundSlice);
+
+function list() {
+  return slice(arguments);
+}
+
+var list1 = list(1, 2, 3); // [1, 2, 3]
+</pre>
+
+<h2 id="Simplificando_o_comportamento_entre_navegadores"><span class="short_text" id="result_box" lang="pt"><span>Simplificando o comportamento entre navegadores</span></span></h2>
+
+<p><span id="result_box" lang="pt"><span>Embora os objetos de host (como objetos DOM) não sejam obrigados pela especificação a seguir o comportamento do Mozilla quando convertidos por Array.prototype.slice e IE &lt;9 não o fazem</span></span>, versões do IE começando pela versão 9 permitem isso. “Shimming” pode permitir um comportamento confiável entre navegadores. Enquanto outros navegadores modernos continuem suportando essa habilidade, como atualmente IE, Mozilla, Chrome, Safari, e Opera fazem, desenvolvedores lendo (DOM-supporting) o código slice confiando neste shim não serão desencaminhados pela semântica; eles podem confiar seguramente na semântica para fornecer o agora aparentemente comportamento padrão de fato. (Isso também corrige o problema com IE &lt; 9 onde o segundo argumento do <code>slice</code> era explicitamente {{jsxref("null")}}/{{jsxref("undefined")}})</p>
+
+<pre class="brush: js notranslate">(function () {
+  'use strict';
+  var _slice = Array.prototype.slice;
+
+  try {
+    // Produzirá erro no IE &lt; 9
+    _slice.call(document.documentElement);
+  } catch (e) {
+    // Funciona para arrays, objetos array-like,
+    // NamedNodeMap (atributos, entidades, notações),
+    // NodeList (por exemplo, getElementsByTagName), HTMLCollection (por exemplo, childNodes),
+    // e não vai falhar em outros objetos do DOM (como falham no IE &lt; 9)
+    Array.prototype.slice = function(begin, end) {
+      end = (typeof end !== 'undefined') ? end : this.length;
+
+      // Para arrays, chamamos o método nativo
+      if (Object.prototype.toString.call(this) === '[object Array]'){
+        return _slice.call(this, begin, end);
+      }
+
+      // Para array-like, o processo é manual.
+      var i, cloned = [],
+        size, len = this.length;
+
+      // Lidando com valor negativo para "begin"
+      var start = begin || 0;
+      start = (start &gt;= 0) ? start : Math.max(0, len + start);
+
+      // Lidando com valor negativo para "end"
+      var upTo = (typeof end == 'number') ? Math.min(end, len) : len;
+      if (end &lt; 0) {
+        upTo = len + end;
+      }
+
+      // Tamanho real do corte feito pelo slice
+      size = upTo - start;
+
+      if (size &gt; 0) {
+        cloned = new Array(size);
+        if (this.charAt) {
+          for (i = 0; i &lt; size; i++) {
+            cloned[i] = this.charAt(start + i);
+          }
+        } else {
+          for (i = 0; i &lt; size; i++) {
+            cloned[i] = this[start + i];
+          }
+        }
+      }
+
+      return cloned;
+    };
+  }
+}());
+</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('ESDraft', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.10', 'Array.prototype.slice')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.2.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{Compat("javascript.builtins.Array.slice")}}</div>
+
+<div id="compat-mobile"></div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function.prototype.call()")}}</li>
+ <li>{{jsxref("Function.prototype.bind()")}}</li>
+ <li>{{jsxref("Array.prototype.splice()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/some/index.html b/files/pt-br/web/javascript/reference/global_objects/array/some/index.html
new file mode 100644
index 0000000000..f4724488dd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/some/index.html
@@ -0,0 +1,134 @@
+---
+title: Array.prototype.some()
+slug: Web/JavaScript/Reference/Global_Objects/Array/some
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/some
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>some()</strong></code> testa se ao menos um dos elementos no array passa no teste implementado pela função atribuída e retorna um valor <code><strong>true</strong></code> ou <code><strong>false</strong></code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.some(<var>callback</var>[, <var>thisArg</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função para testar cada elemento, recebendo três argumentos:
+ <dl>
+  <dt><code>currentValue</code></dt>
+  <dd>O valor atual do elemento sendo processado no array.</dd>
+  <dt><code>index</code></dt>
+  <dd>O índice do elemento atual sendo processado no array.</dd>
+  <dt><code>array</code></dt>
+  <dd>O array onde o método <code>some()</code> foi chamado.</dd>
+ </dl>
+ </dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Opcional. Valor para usar como  <em><code>this</code> </em>durante a execução do <code>callback</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Esta função retorna <code><strong>true</strong></code> se a função callback retornar <code><strong>true</strong></code> para qualquer elemento do array; caso contrário, <code><strong>false</strong></code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>some()</code> executa a função callback uma vez para cada elemento presente no array até achar um onde o <code>callback</code> retorne um valor <em>true</em>. Se em qualquer dos elementos o valor for encontrado, <code>some()</code> imediatamente retorna <code>true</code>. Caso contrario, <code>some()</code> retorna <code>false</code>. <code>callback</code> é invocado somente para índices do array que contenham valor definido; não é invocado para índices que foram deletados ou os quais nunca tiveram valor definido.</p>
+
+<p><code>callback</code> é invocado com três argumentos: o valor do elemento, o índice do elemento, e o array onde a função foi chamada.</p>
+
+<p>Se o parâmetro <code>thisArg</code> foi passado ao <code>some()</code>, ele sera passado ao <code>callback</code> quando o mesmo for invocado,<font face="Open Sans, Arial, sans-serif"> para ser usado como o valor de </font><code>this</code> internamente na função callback. Caso contrario, o valor {{jsxref("undefined")}} será passado para uso como <code>this</code>. O valor <code>this</code> observado pela <code>callback</code>  é determinado de acordo com as regras usuais para determinar o que é visto por uma função.</p>
+
+<p><code>some()</code> não altera o array dentro do qual ele é chamado. </p>
+
+<p>O intervalo de elementos processado por <code>some()</code> é definido antes da primeira invocação da <code>callback</code>. Elementos contidos no array antes da chamada <code>some()</code> ser iniciada não serão testados pela <em>callback</em>. Se algum elemento pertencente ao array for alterado pela <code><var>callback</var></code>, o valor passado para a <code><var>callback</var></code> será o valor do momento em que a função <code>some()</code> encontra o índice daquele elemento. Elementos deletados não são testados.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Testando_valores_de_elementos_de_um_array">Testando valores de elementos de um array</h3>
+
+<p>O exemplo a seguir testa se algum elemento de um array é maior que 10.</p>
+
+<pre class="brush: js notranslate">function isBiggerThan10(element, index, array) {
+  return element &gt; 10;
+}
+[2, 5, 8, 1, 4].some(isBiggerThan10);  // false
+[12, 5, 8, 1, 4].some(isBiggerThan10); // true
+</pre>
+
+<h3 id="Testando_valores_de_elementos_de_um_array_usando_arrow_functions">Testando valores de elementos de um array usando arrow functions</h3>
+
+<p><a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">Arrow functions</a> fornece uma sintaxe mais curta para o mesmo teste.</p>
+
+<pre class="brush: js notranslate">[2, 5, 8, 1, 4].some(elem =&gt; elem &gt; 10);  // false
+[12, 5, 8, 1, 4].some(elem =&gt; elem &gt; 10); // true
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p><code>some()</code> was added to the ECMA-262 standard in the 5th edition; as such it may not be present in all implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of <code>some()</code> in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming {{jsxref("Object")}} and {{jsxref("TypeError")}} have their original values and that <code>fun.call</code> evaluates to the original value of {{jsxref("Function.prototype.call()")}}.</p>
+
+<pre class="brush: js notranslate">// Production steps of ECMA-262, Edition 5, 15.4.4.17
+// Reference: http://es5.github.io/#x15.4.4.17
+if (!Array.prototype.some) {
+  Array.prototype.some = function(fun/*, thisArg*/) {
+    'use strict';
+
+    if (this == null) {
+      throw new TypeError('Array.prototype.some called on null or undefined');
+    }
+
+    if (typeof fun !== 'function') {
+      throw new TypeError();
+    }
+
+    var t = Object(this);
+    var len = t.length &gt;&gt;&gt; 0;
+
+    var thisArg = arguments.length &gt;= 2 ? arguments[1] : void 0;
+    for (var i = 0; i &lt; len; i++) {
+      if (i in t &amp;&amp; fun.call(thisArg, t[i], i, t)) {
+        return true;
+      }
+    }
+
+    return false;
+  };
+}
+</pre>
+
+<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>{{SpecName('ES5.1', '#sec-15.4.4.17', 'Array.prototype.some')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada em JavaScript 1.6.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.some', 'Array.prototype.some')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_navegadores">Compatibilidade em navegadores</h2>
+
+<div>{{Compat("javascript.builtins.Array.some")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+ <li>{{jsxref("TypedArray.prototype.some()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/sort/index.html b/files/pt-br/web/javascript/reference/global_objects/array/sort/index.html
new file mode 100644
index 0000000000..6b1f8fcc15
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/sort/index.html
@@ -0,0 +1,232 @@
+---
+title: Array.prototype.sort()
+slug: Web/JavaScript/Reference/Global_Objects/Array/sort
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/sort
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>sort()</strong></code> ordena os elementos do próprio array e retorna o array. A ordenação não é necessariamente <a href="https://pt.wikipedia.org/wiki/Ordena%C3%A7%C3%A3o_est%C3%A1vel">estável</a>. A ordenação padrão é de acordo com a  pontuação de código unicode.</p>
+
+<p>A complexidade do tempo de execução ou a quantidade de memória utilizada pela ordenação não pode ser garantido e depende da implementação realizada.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.sort([funcaoDeComparacao])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>funcaoDeComparacao</code> {{optional_inline}}</dt>
+ <dd>Especifica uma função que define a ordenação. Se omitido, o array é ordenado de acordo com a pontuação de código <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Unicode">Unicode</a> de cada um dos caracteres, de acordo com a conversão de cada elemento para string.</dd>
+ <dt>    <code>primeiroElemento</code></dt>
+ <dd>    O primeiro elemento para a comparação.</dd>
+ <dt>    <code>segundoElemento</code></dt>
+ <dd>    O segundo elemento para comparação.</dd>
+ <dt>
+ <h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+ </dt>
+ <dd>O array ordenado. Note que o array é ordenado de acordo com a pontuação de código <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Unicode">Unicode</a> de cada um dos caracteres, e nenhuma cópia é feita.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se <strong><code>funcaoDeComparacao</code></strong> não for informado, os elementos serão ordenados de acordo com a sua conversão para texto e o texto comparado na pontuação unicode do texto convertido. Por exemplo, "banana" vem antes de "cherry". Em uma ordenação numérica, 9 vem antes de 80, mas porque os números são convertidos para texto e, "80" vem antes de "9" na ordenação Unicode.</p>
+
+<pre class="brush: js notranslate">var fruit = ['cherries', 'apples', 'bananas'];
+fruit.sort(); // ['apples', 'bananas', 'cherries']
+
+var scores = [1, 10, 2, 21];
+scores.sort(); // [1, 10, 2, 21]
+// Observe que 10 vem antes do 2,
+// porque '10' vem antes de '2' em ponto de código Unicode.
+
+var things = ['word', 'Word', '1 Word', '2 Words'];
+things.sort(); // ['1 Word', '2 Words', 'Word', 'word']
+// Em Unicode, números vêem antes de letras maiúsculas,
+// as quais vêem antes das minúsculas.
+</pre>
+
+<p>Se o parametro <code>funcaoDeComparacao</code> é fornecido, o array será ordenado de acordo com o valor de retorno da <code>funcaoDeComparacao</code>. Considerando que <code>a</code> e <code>b</code> são dois elementos sendo comparados, então:</p>
+
+<ul>
+ <li>Se <code>funcaoDeComparacao(a, b)</code> for menor que 0, ordena <code>a</code> para um índice anterior a <code>b</code>, i.e. a vem primeiro.</li>
+ <li>Se <code>funcaoDeComparacao(a, b)</code> retornar 0, deixa <code>a</code> e <code>b</code> inalterados em relação um ao outro, mas ordenado em relação a todos os outros elementos. Nota: O padrão ECMAscript não garante este comportamento, e, portanto, nem todos os navegadores (e.g. Versões do Mozilla anteriores a 2003) respeitarão isto.</li>
+ <li>Se <code>funcaoDeComparacao(a, b)</code> é maior que 0, ordena b para um índice anterior que a.</li>
+ <li><code>funcaoDeComparacao(a, b)</code> sempre deve retornar o mesmo valor dado um par específico de elementos a e b como seus dois parametros. Se resultados inconsistentes são retornados, então a ordenação é indefinida.</li>
+</ul>
+
+<p>Então, a função de comparação tem a seguinte forma:</p>
+
+<pre class="brush: js notranslate">function comparar(a, b) {
+  if (a é menor que b em algum critério de ordenação) {
+    return -1;
+  }
+  if (a é maior que b em algum critério de ordenação) {
+    return 1;
+  }
+  // a deve ser igual a b
+  return 0;
+}
+</pre>
+
+<p>Para comparar números ao invés de texto, a função de comparação pode simplesmente subtrair b de a. A função abaixo irá ordenar o array em ordem crescente:</p>
+
+<pre class="brush: js notranslate">function compararNumeros(a, b) {
+  return a - b;
+}
+</pre>
+
+<p>O método de ordenação pode convenientemente ser usada com {{jsxref("Operators/function", "funções anônimas", "", 1)}} (e <a href="/en-US/docs/Web/JavaScript/Guide/Closures">closures</a>):</p>
+
+<pre class="brush: js notranslate">var numbers = [4, 2, 5, 1, 3];
+numbers.sort(function(a, b) {
+  return a - b;
+});
+console.log(numbers);
+</pre>
+
+<p>Objetos podem ser ordenados de acordo com o valor de uma de suas propriedades.</p>
+
+<pre class="brush: js notranslate" id="expanded-example">var items = [
+  { name: 'Edward', value: 21 },
+  { name: 'Sharpe', value: 37 },
+  { name: 'And', value: 45 },
+  { name: 'The', value: -12 },
+  { name: 'Magnetic' },
+  { name: 'Zeros', value: 37 }
+];
+items.sort(function (a, b) {
+  if (a.name &gt; b.name) {
+    return 1;
+  }
+  if (a.name &lt; b.name) {
+    return -1;
+  }
+  // a must be equal to b
+  return 0;
+});
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Criando_exibindo_e_ordenando_um_array">Criando, exibindo, e ordenando um array</h3>
+
+<p>O exemplo abaixo cria quatro arrays e mostra seu conteúdo original, então o conteúdo dos arrays ordenado. Os arrays numéricos são ordenados sem a função de comparação, e então, com a função.</p>
+
+<pre class="brush: js notranslate">var stringArray = ['Blue', 'Humpback', 'Beluga'];
+var numericStringArray = ['80', '9', '700'];
+var numberArray = [40, 1, 5, 200];
+var mixedNumericArray = ['80', '9', '700', 40, 1, 5, 200];
+
+function compararNumeros(a, b) {
+  return a - b;
+}
+
+console.log('stringArray:', stringArray.join());
+console.log('Ordenada:', stringArray.sort());
+
+console.log('numberArray:', numberArray.join());
+console.log('Ordenada sem função de comparação:', numberArray.sort());
+console.log('Ordenada com compararNumeros:', numberArray.sort(compararNumeros));
+
+console.log('numericStringArray:', numericStringArray.join());
+console.log('Ordenada sem função de comparação:', numericStringArray.sort());
+console.log('Ordenada com compararNumeros:', numericStringArray.sort(compararNumeros));
+
+console.log('mixedNumericArray:', mixedNumericArray.join());
+console.log('Ordenada sem função de comparação:', mixedNumericArray.sort());
+console.log('Ordenada com compararNumeros:', mixedNumericArray.sort(compararNumeros));
+</pre>
+
+<p>Este exemplo gera a saída abaixo. Como as saídas mostram, quando a função de comparação é usada, os números são ordenados corretamente, sejam eles números ou strings numéricas.</p>
+
+<pre class="notranslate">stringArray: Blue,Humpback,Beluga
+Ordenada: Beluga,Blue,Humpback
+
+numberArray: 40,1,5,200
+Ordenada sem função de comparação: 1,200,40,5
+Ordenada com compararNumeros: 1,5,40,200
+
+numericStringArray: 80,9,700
+Ordenada sem função de comparação: 700,80,9
+Ordenada com compararNumeros: 9,80,700
+
+mixedNumericArray: 80,9,700,40,1,5,200
+Ordenada sem função de comparação: 1,200,40,5,700,80,9
+Ordenada com compararNumeros: 1,5,9,40,80,200,700
+</pre>
+
+<h3 id="Ordenando_caracteres_não-ASCII">Ordenando caracteres não-ASCII</h3>
+
+<p>Para ordenar strings com caracteres não-ASCII, i.e. strings com caracteres acentuados (e, é, è, a, ä, etc.), strings de línguas diferentes do Inglês: use {{jsxref("String.localeCompare")}}. Esta função pode comparar estes caracteres, então eles aparecerão na ordem correta.</p>
+
+<pre class="brush: js notranslate">var items = ['réservé', 'premier', 'cliché', 'communiqué', 'café', 'adieu'];
+items.sort(function (a, b) {
+  return a.localeCompare(b);
+});
+
+// items é ['adieu', 'café', 'cliché', 'communiqué', 'premier', 'réservé']
+</pre>
+
+<h3 id="Ordenando_com_mapa">Ordenando com mapa</h3>
+
+<p>A <code>funcaoDeComparacao</code> pode ser invocada múltiplas vezes por elemento do array. Dependendo da natureza da <code>funcaoDeComparacao</code>, isto pode causar um excesso processamento. Quanto mais trabalho a <code>funcaoDeComparacao</code> fizer, e quanto mais elementos houverem para ordenar, seria mais inteligente considerar  o uso de um mapa para a ordenação. A idéia é percorrer o array uma vez para extrair os valores já processados para a ordenação e armazenar em um array temporário, ordenar o array temporário e então percorrer o array temporário para conseguir a ordenação correta.</p>
+
+<pre class="brush: js notranslate">// o array a ser ordenado
+var list = ['Delta', 'alpha', 'CHARLIE', 'bravo'];
+
+// array temporário que armazena os objetos com o índice e o valor para ordenação
+var mapped = list.map(function(el, i) {
+  return { index: i, value: el.toLowerCase() };
+})
+
+// ordenando o array mapeado contendo os dados resumidos
+mapped.sort(function(a, b) {
+  return +(a.value &gt; b.value) || +(a.value === b.value) - 1;
+});
+
+// container para o resultado ordenado
+var result = mapped.map(function(el){
+  return list[el.index];
+});
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição Inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.11', 'Array.prototype.sort')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.sort', 'Array.prototype.sort')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div id="compat-desktop">{{Compat("javascript.builtins.Array.sort")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.reverse()")}}</li>
+ <li>{{jsxref("String.prototype.localeCompare()")}}</li>
+</ul>
+
+<div id="link64_adl_tabid" style="display: none;">253</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/splice/index.html b/files/pt-br/web/javascript/reference/global_objects/array/splice/index.html
new file mode 100644
index 0000000000..d9296f4101
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/splice/index.html
@@ -0,0 +1,173 @@
+---
+title: Array.prototype.splice()
+slug: Web/JavaScript/Reference/Global_Objects/Array/splice
+tags:
+  - Array
+  - JavaScript
+  - Lista
+  - splice
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/splice
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Resumo">Resumo</h2>
+
+<p>O método <strong>splice() </strong>altera o conteúdo de uma lista, adicionando novos elementos enquanto remove elementos antigos.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>array</em>.splice(<em>indice</em>[,<em> deleteCount</em>[<em>,</em><em> elemento1</em>[, ...[, <em>elementoN</em>]]])</code>
+
+<code><em>array</em>.splice(<em>indice</em>) // SpiderMonkey/Firefox extension</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>indice</code></dt>
+ <dd>Índice o qual deve iniciar a alterar a lista. Se maior que o tamanho total da mesma, nenhum elemento será alterado. Se negativo, irá iniciar a partir daquele número de elementos a partir do fim.</dd>
+</dl>
+
+<dl>
+ <dt><code>deleteCount</code></dt>
+ <dd>Um inteiro indicando o número de antigos elementos que devem ser removidos.</dd>
+ <dd>Se o parâmetro <code><em>deleteCount</em></code> não é especificado, ou se é maior que o número de elementos restantes na lista iniciando pelo índice, então todos os elementos até o fim da lista serão deletados.</dd>
+ <dd>Se <code><em>deleteCount</em></code> é 0, nenhum elemento é removido. Neste caso você deve especificar pelo menos um novo elemento.</dd>
+</dl>
+
+<dl>
+ <dt><code>elemento1, ..., elemento<em>N</em></code></dt>
+ <dd>Os elementos a adicionar na lista. Se você não especificar nenhum elemento, splice simplesmente removerá elementos da mesma.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Uma lista contendo os elementos removidos. Se apenas um elemento é removido, por exemplo, uma lista contendo apenas um elemento é retornada. Se nenhum elemento é removido, uma lista vazia é retornada.</p>
+
+<p><strong style="font-size: 30px; font-weight: 700; letter-spacing: -1px; line-height: 30px;">Descrição</strong></p>
+
+<p>Se você especificar um número diferente de elementos a inserir comparado ao número de elementos que você está removendo, a lista terá um tamanho diferente no final da execução.</p>
+
+<h2 id="Exemplo">Exemplo</h2>
+
+<h3 id="Exemplo_Removendo_0_elementos_do_indice_2_e_inserindo_drum">Exemplo: Removendo 0 elementos do indice 2, e inserindo "drum"</h3>
+
+<p>O script a seguir ilustra o uso do <em>splice</em>:</p>
+
+<pre class="brush: js">var myFish = ["angel", "clown", "mandarin", "surgeon"];
+
+//remove 0 elementos a partir do índice 2, e insere "drum"
+var removed = myFish.splice(2, 0, "drum");
+//myFish é ["angel", "clown", "drum", "mandarin", "surgeon"]
+//removed é [], nenhum elemento removido
+
+//remove 1 elemento do índice 3
+removed = myFish.splice(3, 1);
+//myFish é ["angel", "clown", "drum", "surgeon"]
+//removed é ["mandarim"]
+
+//remove 1 elemento a partir do índice 2, e insere "trumpet"
+removed = myFish.splice(2, 1, "trumpet");
+//myFish é ["angel", "clown", "trumpet", "surgeon"]
+//removed é ["drum"]
+
+//remove 2 elementos a partir do índice 0, e insere "parrot", "anemone" e "blue"
+removed = myFish.splice(0, 2, "parrot", "anemone", "blue");
+//myFish é ["parrot", "anemone", "blue", "trumpet", "surgeon"]
+//removed é ["angel", "clown"]
+
+//remove 2 elementos a partir do indice 3
+removed = myFish.splice(3, Number.MAX_VALUE);
+//myFish é ["parrot", "anemone", "blue"]
+//removed é ["trumpet", "surgeon"]</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>ECMAScript 3rd Edition</td>
+   <td>Padrão</td>
+   <td>Definição inicial.<br>
+    Implementado no JavaScript 1.2</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.12', 'Array.prototype.splice')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.splice', 'Array.prototype.splice')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Atributo</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>1.0</td>
+   <td>{{CompatGeckoDesktop("1.7")}}</td>
+   <td>5.5</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Atributo</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="Compatibilidade_com_Navegadores_Antigos">Compatibilidade com Navegadores Antigos</h3>
+
+<p>O método <em>splice</em> retorna o elemento removido, se somente um elemento é removido (parâmetro <code><em>deleteCount</em></code> é 1); caso contrário, o método retorna uma lista contendo os elementos removidos. Note que o último navegador a utilizar JavaScript 1.2 foi o Netscape Navigator 4, então você pode utilizar o <em>splice</em> esperando sempre retornar uma lista.</p>
+
+<h2 id="See_also" name="See_also">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Array.push", "push")}} / {{jsxref("Array.pop", "pop")}} - adiciona/remove elementos do final do array;</li>
+ <li>{{jsxref("Array.unshift", "unshift")}} / {{jsxref("Array.shift", "shift")}} - adiciona/remove elementos do início do array;</li>
+ <li>{{jsxref("Array.concat", "concat")}} - returns a new array comprised of this array joined with other array(s) and/or value(s).</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html b/files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html
new file mode 100644
index 0000000000..7912113ff7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/tolocalestring/index.html
@@ -0,0 +1,140 @@
+---
+title: Array.prototype.toLocaleString()
+slug: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/toLocaleString
+---
+<div>{{JSRef}}</div>
+
+<div>O método <code><strong>toLocaleString()</strong></code> retorna uma representaçao de elementos de um array. Os elementos são convertidos para Strings utilizando seus respectivos métodos <code>toLocaleString</code> e essas cadeias são separadas por uma sequência específica de localidade (separados por virgula ","). </div>
+
+<div> </div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>array</var>.toLocaleString();</code>
+</pre>
+
+<p> </p>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>locales</code> {{optional_inline}}</dt>
+ <dd>Uma string com uma tag de linguagem BCP 47, ou um array como strings. Para uma forma geral e uma interpretação do arquivo <code>locales</code>, veja a página {{jsxref("Intl")}}.</dd>
+ <dt><code>options</code> {{optional_inline}}</dt>
+ <dd>Um objeto com as propriedades de configurações, para números veja {{jsxref("Number.prototype.toLocaleString()")}}, e para datas veja {{jsxref("Date.prototype.toLocaleString()")}}.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Uma string que representa os elementos de um array.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toLocaleString">Usando <code>toLocaleString</code></h3>
+
+<p>Os elementos de um array são convertidos para strings usando seus respectivos métodos <code>toLocaleString:</code></p>
+
+<ul>
+ <li><code>Object</code>: {{jsxref("Object.prototype.toLocaleString()")}}</li>
+ <li><code>Number</code>: {{jsxref("Number.prototype.toLocaleString()")}}</li>
+ <li><code>Date</code>: {{jsxref("Date.prototype.toLocaleString()")}}</li>
+</ul>
+
+<pre class="brush: js">var numero = 1337;
+var data = new Date();
+var meuArray = [numero, data, 'foo'];
+
+var resultado = meuArray.toLocaleString();
+
+console.log(resultado);
+// saída '1337,July 26, 2015 at 20:02:23 GMT-3,foo'
+// se estiver no Brasil com o fuso horario GMT-0300 (BRT) de Brasília.
+</pre>
+
+<p>Para mais exemplos, veja as páginas {{jsxref("Intl")}}, {{jsxref("NumberFormat")}}, e {{jsxref("DateTimeFormat")}}.</p>
+
+<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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.3', 'Array.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.tolocalestring', 'Array.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_Browser">Compatibilidade do Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html
new file mode 100644
index 0000000000..0eeea7211c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/tosource/index.html
@@ -0,0 +1,113 @@
+---
+title: Array.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Array/toSource
+tags:
+  - Não-padrão
+  - Referencia
+  - prototipos
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O método <code><strong>toSource()</strong></code> retorna uma representação string do código fonte do array.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.toSource()</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>toSource</code> retorna os seguintes valores:</p>
+
+<ul>
+ <li>Para o objeto {{jsxref("Array")}} pré-construido, <code>toSource</code> retorna a seguinte string indicando que o código fonte não está disponível:
+
+  <pre class="brush: js">function Array() {
+    [native code]
+}
+</pre>
+ </li>
+ <li>Para instancias de {{jsxref("Array")}}, <code>toSource</code> retorna uma representação string do código fonte.</li>
+</ul>
+
+<p>Este método normalmente é chamando internamente pelo JavaScript e não explicitamente no código. Você pode chamar <code>toSource</code> durante o debug para examinar o conteúdo de um array.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Examinando_o_código_fonte_de_um_array">Examinando o código fonte de um array</h3>
+
+<p>Para examinar o código fonte de um array:</p>
+
+<pre class="brush: js">var alpha = new Array('a', 'b', 'c');
+
+alpha.toSource();   //retorna ['a', 'b', 'c']
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não é parte de nenhum padrão. Implementado no JavaScript 1.3.</p>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<p>A tabela de compatibilidade encontrada nesta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, consulte <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um "pull request".</p>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+ <li>{{jsxref("Array.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html
new file mode 100644
index 0000000000..d10cd2e032
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/tostring/index.html
@@ -0,0 +1,115 @@
+---
+title: Array.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Array/toString
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/toString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>toString()</strong></code> retorna uma string representando um array específico e seus elementos.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.toString()</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O objeto {{jsxref("Array")}} substitui o método toString() de {{jsxref("Object")}}. Para objetos do tipo Array, o método toString() concatena todos os valores em apenas uma string. Segue exemplo abaixo, de como ele se comporta.</p>
+
+<pre class="brush: js">var monthNames = ['Jan', 'Feb', 'Mar', 'Apr'];
+var myVar = monthNames.toString(); // atribui 'Jan,Feb,Mar,Apr' para myVar.
+</pre>
+
+<p>JavaScript chama o método toString automaticamente quando um Array é para ser representado como um valor de texto ou quando um Array é designado em uma concatenação.</p>
+
+<h3 id="Semântica_ECMAScript_5">Semântica ECMAScript 5</h3>
+
+<p>Implementado no JavaScript 1.8.5 (Firefox 4), e compatível com a 5ª versão do ECMAScript, a função toString() é genérica e pode ser usada em qualquer Objeto. Se o objeto tem um método join(), ele será chamado e esse valor será devolvido. Do contrário, {{jsxref("Object.prototype.toString()")}} será chamado, e o valor será retornado.</p>
+
+<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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.2', 'Array.prototype.toString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.tostring', 'Array.prototype.toString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browsers_compatíveis">Browsers compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html b/files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html
new file mode 100644
index 0000000000..a509f16afb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/unobserve/index.html
@@ -0,0 +1,129 @@
+---
+title: Array.unobserve()
+slug: Web/JavaScript/Reference/Global_Objects/Array/unobserve
+translation_of: Archive/Web/JavaScript/Array.unobserve
+---
+<div>{{JSRef}}</div>
+
+<div>O método Array<strong>.unobserve()</strong> é usado para remover observers adicionados pelo {{jsxref("Array.observe()")}}.</div>
+
+<div> </div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Array.unobserve(<var>arr</var>, <var>callback</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>arr</code></dt>
+ <dd>O array para remover os observers.</dd>
+ <dt><code>callback</code></dt>
+ <dd><code>A referência para o observer para parar de ser chamada a toda vez em que algo é modificado no array </code><strong>arr</strong>.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Array.unobserve()</code> deve ser chamado após o  {{jsxref("Array.observe()")}} a fim de remover um observers de um array.</p>
+
+<p>O callback deve ser uma referencia à uma função e não a uma função anônima, porquê esta referencia será usada para remover o observer anterior. É inútil chamar o <strong>Array.unobserve() </strong>com uma função anônima como callback, não removerá nenhum observer.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Desobservando_um_array">Desobservando um array</h3>
+
+<pre class="brush: js">var arr = [1, 2, 3];
+
+var observer = function(changes) {
+  console.log(changes);
+}
+
+Array.observe(arr, observer);
+​
+arr.push(4);
+// [{type: "splice", object: &lt;arr&gt;, index: 3, removed:[], addedCount: 1}]
+
+Array.unobserve(arr, observer);
+
+arr.pop();
+// O callback não foi chamado</pre>
+
+<h3 id="Usando_uma_função_anônima">Usando uma função anônima</h3>
+
+<pre class="brush: js">var persons = ['Khalid', 'Ahmed', 'Mohammed'];
+
+Array.observe(persons, function (changes) {
+  console.log(changes);
+});
+
+persons.shift();
+// [{type: "splice", object: &lt;arr&gt;, index: 0, removed: [ "Khalid" ], addedCount: 0 }]
+
+Array.unobserve(persons, function (changes) {
+  console.log(changes);
+});
+
+persons.push('Abdullah');
+// [{type: "splice", object: &lt;arr&gt;, index: 2, removed: [], addedCount: 1 }]
+// O callback sempre será chamado
+</pre>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("36")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("23")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("36")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("23")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Array.observe()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Object.observe()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Object.unobserve()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html b/files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html
new file mode 100644
index 0000000000..bdf6c0e4d9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/unshift/index.html
@@ -0,0 +1,90 @@
+---
+title: Array.prototype.unshift()
+slug: Web/JavaScript/Reference/Global_Objects/Array/unshift
+tags:
+  - Array
+  - JavaScript
+  - Prototype
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/unshift
+---
+<div>{{JSRef("Global_Objects", "Array")}}</div>
+
+<h2 id="Summary" name="Summary">Introdução</h2>
+
+<p>O método <code><strong>unshift()</strong></code> adiciona um ou mais elementos no início de um array e retorna o número de elementos (propriedade <code style="font-style: normal;">length</code>) atualizado.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>arr</var>.unshift([<var>element1</var>[, ...[, <var>elementN</var>]]])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>element<em>N</em></code></dt>
+ <dd>Os elementos a serem adicionados no começo do array.</dd>
+</dl>
+
+<h3 id="Returns" name="Returns">Retorna</h3>
+
+<p>A nova propriedade {{jsxref("Array.length", "length")}} do objeto acima onde o método foi chamado.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O método <code>unshift</code> insere os valores fornecidos no início de um objeto do tipo array.</p>
+
+<p><code>unshift</code> é intencionalmente genérico; este método pode ser chamado via {{jsxref("Function.call", "call", "", 1)}} ou {{jsxref("Function.apply", "apply", "", 1)}} em objetos que se assemelham aos arrays. <span style="line-height: 1.5;">Objetos que não contêm uma propriedade </span><code style="font-style: normal; line-height: 1.5;">length</code><span style="line-height: 1.5;"> que reflete a última de uma série consecutiva de propriedades numéricas, </span><span style="line-height: 1.5;">iniciada por 0, podem não comportar-se de maneira significativa.</span></p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<pre class="brush: js notranslate">var arr = [1, 2];
+
+arr.unshift(0); // result of call is 3, the new array length
+// arr is [0, 1, 2]
+
+arr.unshift(-2, -1); // = 5
+// arr is [-2, -1, 0, 1, 2]
+
+arr.unshift([-3]);
+// arr is [[-3], -2, -1, 0, 1, 2]
+</pre>
+
+<h2 id="Specifications" name="Specifications">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>ECMAScript 3ª Edição</td>
+   <td>Padrão</td>
+   <td>Definição inicial. Implementado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.4.4.13', 'Array.prototype.unshift')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-array.prototype.unshift', 'Array.prototype.unshift')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade entre browsers</h2>
+
+<div>{{Compat("javascript.builtins.Array.unshift")}}</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.push()")}}</li>
+ <li>{{jsxref("Array.prototype.pop()")}}</li>
+ <li>{{jsxref("Array.prototype.shift()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/array/values/index.html b/files/pt-br/web/javascript/reference/global_objects/array/values/index.html
new file mode 100644
index 0000000000..d3e918e1b9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/array/values/index.html
@@ -0,0 +1,121 @@
+---
+title: Array.prototype.values()
+slug: Web/JavaScript/Reference/Global_Objects/Array/values
+translation_of: Web/JavaScript/Reference/Global_Objects/Array/values
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>values()</code></strong> retorna um novo objeto de  <strong><code>Array Iterator</code></strong> que contém os valores para cada índice no array.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>arr</var>.values()</code></pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Iteração_usando_for...of_loop">Iteração usando <code>for...of</code> loop</h3>
+
+<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
+var eArr = arr.values();
+// seu navegador deve suportar for..of loop
+// e deixar variáveis let-scoped no for loops
+for (let letter of eArr) {
+  console.log(letter);
+}
+</pre>
+
+<h3 id="Iteração_alternativa">Iteração alternativa</h3>
+
+<pre class="brush: js">var arr = ['w', 'y', 'k', 'o', 'p'];
+var eArr = arr.values();
+console.log(eArr.next().value); // w
+console.log(eArr.next().value); // y
+console.log(eArr.next().value); // k
+console.log(eArr.next().value); // o
+console.log(eArr.next().value); // p
+</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-array.prototype.values', 'Array.prototype.values')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h2>
+
+<ul>
+ <li>Devido a um <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=875433">problema de compatibilidade</a>, <code>Array.prototype.values()</code> foi removido do  SpiderMonkey por enquanto.</li>
+</ul>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.keys()")}}</li>
+ <li>{{jsxref("Array.prototype.entries()")}}</li>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Array.prototype.every()")}}</li>
+ <li>{{jsxref("Array.prototype.some()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/arraybuffer/index.html b/files/pt-br/web/javascript/reference/global_objects/arraybuffer/index.html
new file mode 100644
index 0000000000..443a570305
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/arraybuffer/index.html
@@ -0,0 +1,148 @@
+---
+title: ArrayBuffer
+slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+tags:
+  - ArrayBuffer
+  - Constructor
+  - JavaScript
+  - TypedArrays
+translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
+---
+<p>{{JSRef}}</p>
+
+<p>O objeto <strong><code>ArrayBuffer</code></strong> é um tipo de dado usado para representar um genérico, <span class="short_text" id="result_box" lang="pt"><span class="hps">buffer de</span> <span class="hps">dados binários</span> <span class="hps">de tamanho</span> <span class="hps">fixo</span></span>. Você não pode manipular diretamente os conteúdos de um <code>ArrayBuffer</code>;  em vez disso, você cria um objeto <a href="/en/JavaScript_typed_arrays/ArrayBufferView" title="en/JavaScript typed arrays/ArrayBufferView"><code>ArrayBufferView</code></a> que representa o buffer em um formato específico, e usa para ler e escrever os conteúdos do buffer.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/arraybuffer-constructor.html")}}</p>
+
+<div class="hidden">
+<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
+</div>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre>new ArrayBuffer(length)
+</pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>length</code></dt>
+ <dd>The size, in bytes, of the array buffer to create.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>A new <code>ArrayBuffer</code> object of the specified size. Its contents are initialized to 0.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<p>A {{jsxref("RangeError")}} is thrown if the <code>length</code> is larger than {{jsxref("Number.MAX_SAFE_INTEGER")}} (&gt;= 2 ** 53) or negative.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>The <code>ArrayBuffer</code> constructor creates a new <code>ArrayBuffer</code> of the given length in bytes.</p>
+
+<h3 id="Getting_an_array_buffer_from_existing_data">Getting an array buffer from existing data</h3>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">From a Base64 string</a></li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/FileReader#readAsArrayBuffer()">From a local file</a></li>
+</ul>
+
+<h2 id="Properties">Properties</h2>
+
+<dl>
+ <dt><code>ArrayBuffer.length</code></dt>
+ <dd>The <code>ArrayBuffer</code> constructor's length property whose value is 1.</dd>
+ <dt>{{jsxref("ArrayBuffer.@@species", "get ArrayBuffer[@@species]")}}</dt>
+ <dd>The constructor function that is used to create derived objects.</dd>
+ <dt>{{jsxref("ArrayBuffer.prototype")}}</dt>
+ <dd>Allows the addition of properties to all <code>ArrayBuffer</code> objects.</dd>
+</dl>
+
+<h2 id="Methods">Methods</h2>
+
+<dl>
+ <dt>{{jsxref("ArrayBuffer.isView", "ArrayBuffer.isView(arg)")}}</dt>
+ <dd>Returns <code>true</code> if <code>arg</code> is one of the ArrayBuffer views, such as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">typed array objects</a> or a {{jsxref("DataView")}}. Returns <code>false</code> otherwise.</dd>
+ <dt>{{jsxref("ArrayBuffer.transfer", "ArrayBuffer.transfer(oldBuffer [, newByteLength])")}} {{experimental_inline}}</dt>
+ <dd>
+ <p>Returns a new <code>ArrayBuffer</code> whose contents are taken from the <code>oldBuffer</code>'s data and then is either truncated or zero-extended by <code>newByteLength</code>.</p>
+ </dd>
+</dl>
+
+<h2 id="Instances">Instances</h2>
+
+<p>All <code>ArrayBuffer</code> instances inherit from {{jsxref("ArrayBuffer.prototype")}}.</p>
+
+<h3 id="Properties_2">Properties</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Properties')}}</p>
+
+<h3 id="Methods_2">Methods</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Methods')}}</p>
+
+<dl>
+ <dt>{{jsxref("ArrayBuffer.slice()")}} {{non-standard_inline}}</dt>
+ <dd>Has the same functionality as {{jsxref("ArrayBuffer.prototype.slice()")}}.</dd>
+</dl>
+
+<h2 id="Exemplo">Exemplo</h2>
+
+<p>In this example, we create a 8-byte buffer with a {{jsxref("Global_Objects/Int32Array", "Int32Array")}} view referring to the buffer:</p>
+
+<pre><code>var buffer = new ArrayBuffer(8);
+var view   = new Int32Array(buffer);</code></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('Typed Array')}}</td>
+   <td>{{Spec2('Typed Array')}}</td>
+   <td>Substituído pelo ECMAScript 6</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial no ECMA standard. Specified that <code>new</code> is required.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_Navegadores">Compatibilidade entre Navegadores</h2>
+
+<div class="hidden">
+<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+</div>
+
+<p>{{Compat("javascript.builtins.ArrayBuffer")}}</p>
+
+<h2 id="Compatibility_notes">Compatibility notes</h2>
+
+<p>Starting with ECMAScript 2015, <code>ArrayBuffer</code> constructors require to be constructed with a {{jsxref("Operators/new", "new")}} operator. Calling an <code>ArrayBuffer</code> constructor as a function without <code>new</code>, will throw a {{jsxref("TypeError")}} from now on.</p>
+
+<pre class="brush: js example-bad">var dv = ArrayBuffer(10);
+// TypedError: calling a builtin ArrayBuffer constructor
+// without new is forbidden</pre>
+
+<pre class="brush: js example-good">var dv = new ArrayBuffer(10);</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typed arrays</a></li>
+ <li>{{jsxref("SharedArrayBuffer")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/asyncfunction/index.html b/files/pt-br/web/javascript/reference/global_objects/asyncfunction/index.html
new file mode 100644
index 0000000000..3a463c8184
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/asyncfunction/index.html
@@ -0,0 +1,173 @@
+---
+title: AsyncFunction
+slug: Web/JavaScript/Reference/Global_Objects/AsyncFunction
+tags:
+  - Constructor
+  - Construtor
+  - Experimental
+  - JavaScript
+  - Reference
+  - Referência(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/AsyncFunction
+---
+<div>{{JSRef}}</div>
+
+<p>O <strong>construtor</strong> <code><strong>Async</strong></code><strong><code>Function</code> </strong>cria um novo objeto {{jsxref("Statements/async_function", "async function")}}. Em JavaScript cada função assíncrona é atualmente um objeto do tipo <code>AsyncFunction</code>.</p>
+
+<p>Note que<code>AsyncFunction</code> não é um objeto global. Ele poderia ser obtido analisando o seguinte código:</p>
+
+<pre class="brush: js">Object.getPrototypeOf(async function(){}).constructor
+</pre>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">new AsyncFunction([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
+ <dd>Nomes que vão ser usados pela função como argumentos formais. Cada um deve ser uma string que corresponde a um indentificador JavaScript válido ou uma lista das strings separadas com uma vírgula; por exemplo "<code>x</code>", "<code>oValor</code>", or "<code>a,b</code>".</dd>
+ <dt><code>functionBody</code></dt>
+ <dd>Uma string contendo as declarações JavaScript que compõem a definição da função.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Objetos {{jsxref("Statements/async_function", "async function")}} criados com o construtor <code>AsyncFunction</code> são tratados quando a função é criada. Isso é menos eficiente que declarar uma função async com a {{jsxref("Statements/async_function", "expression async function")}} e chama-la com seu código, porque essas funções são tratadas com o resto do código.</p>
+
+<p>Todos os argumentos passado para a função são tratados como nomes dos identificadores dos parâmetros na função que vai ser criada, na ordem que eles são passados.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> {{jsxref("Statements/async_function", "async functions")}} criadas com o construtor <code>AsyncFunction</code> não cria closures para seus contextos de criação; elas sempre criadas no escopo global. Quando rodar eles, eles só poderão acessar suas variáveis local e as globais, mas não as que estão no escopo que o construtor foi <code>AsyncFunction</code> chamado. Isso é diferente de usar {{jsxref("Global_Objects/eval", "eval")}} com código para uma expressão async function.</p>
+</div>
+
+<p>Invocar o construtor <code>AsyncFunction</code> como uma função (sem usar o operador <code>new</code>) tem o mesmo efeito de invocá-lo como um construtor.</p>
+
+<h2 id="Propriedas">Propriedas</h2>
+
+<dl>
+ <dt><code><strong>AsyncFunction.length</strong></code></dt>
+ <dd>A propriedade tamanho do construtor da <code>AsyncFunction</code> cujo valor é 1.</dd>
+ <dt>{{jsxref("AsyncFunction.prototype")}}</dt>
+ <dd>Permite a adição de propriedades para todos os objetos async function.</dd>
+</dl>
+
+<h2 id="AsyncFunction_prototype_object"><code>AsyncFunction </code>prototype object</h2>
+
+<h3 id="Propriedades">Propriedades</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype', 'Propriedades')}}</div>
+
+<h2 id="AsyncFunction_instances"><code>AsyncFunction</code> instances</h2>
+
+<p>Instância <code>AsyncFunction</code> herdam métodos e propriedades do {{jsxref("AsyncFunction.prototype")}}. Com todos os contrutores, que podem mudar o prototype do objeto construtor para fazer mudanças em todas as instâncias do <code>AsyncFunction</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Criando_uma_async_function_a_partir_do_construtor_de_uma_AsyncFunction">Criando uma async function a partir do construtor de uma <code>AsyncFunction</code></h3>
+
+<pre class="brush: js">function resolveAfter2Seconds(x) {
+  return new Promise(resolve =&gt; {
+    setTimeout(() =&gt; {
+      resolve(x);
+    }, 2000);
+  });
+}
+
+var AsyncFunction = Object.getPrototypeOf(async function(){}).constructor
+
+var a = new AsyncFunction('a',
+                          'b',
+                          'return await resolveAfter2Seconds(a) + await resolveAfter2Seconds(b);');
+
+a(10, 20).then(v =&gt; {
+  console.log(v); // imprime 30 após 4 seconds
+});
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-async-function-objects', 'AsyncFunction object')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definição inicial no ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th> Edge</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(55)}}</td>
+   <td>{{CompatGeckoDesktop("52.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOpera(42)}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("52.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOpera(42)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatChrome(55)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/async_function", "async function function")}}</li>
+ <li>{{jsxref("Operators/async_function", "async function expression")}}</li>
+ <li>{{jsxref("Global_Objects/Function", "Function")}}</li>
+ <li>{{jsxref("Statements/function", "function statement")}}</li>
+ <li>{{jsxref("Operators/function", "function expression")}}</li>
+ <li>{{jsxref("Functions_and_function_scope", "Funções e escopo de função", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/atomics/add/index.html b/files/pt-br/web/javascript/reference/global_objects/atomics/add/index.html
new file mode 100644
index 0000000000..6d187893bb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/atomics/add/index.html
@@ -0,0 +1,132 @@
+---
+title: Atomics.add()
+slug: Web/JavaScript/Reference/Global_Objects/Atomics/add
+tags:
+  - Atomics
+  - Atômico
+  - JavaScript
+  - Memória Compartilhada
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics/add
+---
+<div>{{JSRef}}</div>
+
+<p>O método estátitico <code><strong>Atomics</strong></code><strong><code>.add()</code></strong> adiciona um dado valor em uma determinada posição no array e retorna o valor antigo daquela posição. Esta operação atômica garante que nenhuma outra escrita ocorra até que o valor modificado seja escrito de volta.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Atomics.add(typedArray, index, value)
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>typedArray</code></dt>
+ <dd>Um array tipado de inteiros compartilhado. Pode ser {{jsxref("Int8Array")}}, {{jsxref("Uint8Array")}}, {{jsxref("Int16Array")}}, {{jsxref("Uint16Array")}}, {{jsxref("Int32Array")}}, ou {{jsxref("Uint32Array")}}.</dd>
+ <dt><code>index</code></dt>
+ <dd>A posição no <code>typedArray</code> onde o <code>value</code> será adicionado.</dd>
+ <dt><code>value</code></dt>
+ <dd>Número que será adicionado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O valor antigo na determinada posição (<code>typedArray[index]</code>).</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<ul>
+ <li>Lança uma exceção {{jsxref("TypeError")}}, se o <code>typedArray</code> não for um dos tipos de inteiro permitidos.</li>
+ <li>Lança uma exceção {{jsxref("TypeError")}}, se o <code>typedArray</code> não for tipo array tipado compartilhado.</li>
+ <li>Lança uma exceção {{jsxref("RangeError")}}, se o <code>index</code> estiver fora dos limites no <code>typedArray</code>.</li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var sab = new SharedArrayBuffer(1024);
+var ta = new Uint8Array(sab);
+
+Atomics.add(ta, 0, 12); // retorna 0, o valor antigo
+Atomics.load(ta, 0); // 12</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('ESDraft', '#sec-atomics.add', 'Atomics.add')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definição inicial no ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}} [2]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoDesktop("55")}} [1]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("55")}} [1]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] No Firefox da versão 46 até a versão 54, este recurso fica desabilitado por uma configuração. Em about:config, altere o <code>javascript.options.shared_memory</code> para <code>true</code>. </p>
+
+<p>[2] A implementação está sob desenvolvimento e necessita dessas flags de runtime: <code>--js-flags=--harmony-sharedarraybuffer --enable-blink-feature=SharedArrayBuffer</code></p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Atomics")}}</li>
+ <li>{{jsxref("Atomics.sub()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/atomics/index.html b/files/pt-br/web/javascript/reference/global_objects/atomics/index.html
new file mode 100644
index 0000000000..6f6a1dfabe
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/atomics/index.html
@@ -0,0 +1,155 @@
+---
+title: Atomics
+slug: Web/JavaScript/Reference/Global_Objects/Atomics
+translation_of: Web/JavaScript/Reference/Global_Objects/Atomics
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>O objeto <strong><code>Atomics </code></strong>fornece operações atômicas como metodos estáticos. Eles são usados com objetos {{jsxref("SharedArrayBuffer")}}.</p>
+
+<p>As operações atômicas estão localizadas no modulo <code>Atomics</code>. Diferente de outros <em>global objects</em>, <code>Atomics</code> não é um construtor. Você não deve usa-lo com o <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a> ou invocar objetos <code>Atomics</code> como funções. Todas as propriedades e método do <code>Atomics</code> são estáticos (como é o caso com o objeto {{jsxref("Math")}}, por exemplo).</p>
+
+<h2 id="Métodos">Métodos</h2>
+
+<h3 id="Operações_Atômicas">Operações Atômicas</h3>
+
+<p>Quando a memória é compartilhada, multiplas threads podem ser lidas e escritas no mesmo dado da memória. Operações atômicas garantem que os valores previstos sejam lidos e escritos, estas operações são finalizadas antes da próxima operação iniciar e que as mesmas não sejam interrompidas.</p>
+
+<dl>
+ <dt>{{jsxref("Atomics.add()")}}</dt>
+ <dd>Adiciona o valor recebido na posiçao recebida no array. Retorna o valor anterior nesta posição.</dd>
+ <dt>{{jsxref("Atomics.and()")}}</dt>
+ <dd>Calcula um bit a bit AND na posição recebida no array. Retorna o valor anterior nesta posição.</dd>
+ <dt>{{jsxref("Atomics.compareExchange()")}}</dt>
+ <dd>Armazena o valor recebido na posição recebida no array, se este foi igual ao valor recebido. Retorna o valor anterior nesta posição.</dd>
+ <dt>{{jsxref("Atomics.exchange()")}}</dt>
+ <dd>Armazena o valor recebido na posição recebida no array. Retorna o valor anterior.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Atomics.load()")}}</dt>
+ <dd>Retorna o valor na posição recebida no array.</dd>
+ <dt>{{jsxref("Atomics.or()")}}</dt>
+ <dd>Calcula um bit a bit OR na posição recebida no array. Retorna o valor anterior nesta posição.</dd>
+ <dt>{{jsxref("Atomics.store()")}}</dt>
+ <dd>Armazena o valor recebido na posição recebida no array. Retorna o valor.</dd>
+ <dt>{{jsxref("Atomics.sub()")}}</dt>
+ <dd>Subtrai o valor recebido na posição recebida no array. Retorna o valor anterior nesta posição.</dd>
+ <dt>{{jsxref("Atomics.xor()")}}</dt>
+ <dd>Calcula um bit a bit XOR na posição recebida no array. Retorna o valor anterior nesta posição.</dd>
+</dl>
+
+<h3 id="Wait_e_wake">Wait e wake</h3>
+
+<p>Os métodos <code>wait()</code> e <code>wake()</code> são modelados no Linux futexes ("fast user-space mutex") e fornece formas de aguardar até que certas condições se tornem <code>true</code> e são tipicamente usadas como construtores de bloco.</p>
+
+<dl>
+ <dt>{{jsxref("Atomics.wait()")}}</dt>
+ <dd>
+ <p>Verifica se a posição informada no array ainda contém a valor recebido e <span id="result_box" lang="pt"><span>dorme</span> <span>à espera</span> <span>ou</span> até o <span>tempo limite. Retorna </span></span> <code>"ok"</code>, <code>"not-equal"</code>, ou <code>"timed-out"</code>. <span id="result_box" lang="pt"><span>Se</span> a <span>espera não</span> for<span> permitida</span> <span>no agente</span> <span>de chamada</span> <span>ele irá lançar uma exceção</span> <span>de erro (muitos navegadores não permitem </span></span> <code>wait()</code> na thread main do navegador).</p>
+ </dd>
+ <dt>{{jsxref("Atomics.wake()")}}</dt>
+ <dd>"Acorda" alguns agentes que estavam "dormindo" na lista de espera na posição recebida do array. Retorna o número de agentes que estão sendo "acordados".</dd>
+ <dt>{{jsxref("Atomics.isLockFree()", "Atomics.isLockFree(size)")}}</dt>
+ <dd>
+ <p><span id="result_box" lang="pt"><span>Uma otimização</span> <span>primitiva</span> <span>que</span> <span>pode</span> <span>ser usada para</span> <span>determinar se deve ser usado</span> lock<span> ou</span> <span>operações</span> <span>atômicas. Retorna <code>true</code>, se</span> <span>uma operação</span> <span>atômica</span> <span>em matrizes</span> <span>de</span> um <span>dado</span> <span>tamanho do elemento</span> <span>vai</span> <span>ser</span> <span>implementado</span> <span>utilizando uma operação</span> <span>atômica</span> <span>de hardware</span> <span>(</span><span>como</span> <span>oposição a lock)</span><span>.</span> <span>Só para experientes</span><span>.</span></span></p>
+ </dd>
+</dl>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('Shared Memory', '#AtomicsObject', 'Atomics')}}</td>
+   <td>{{Spec2('Shared Memory')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}} [2]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoDesktop("46")}} [1] [3]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("46")}} [1]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] This feature is disabled by a preference setting. In about:config, set <code>javascript.options.shared_memory</code> to <code>true</code>. </p>
+
+<p>[2] The implementation is under development and needs these runtime flags: <code>--js-flags=--harmony-sharedarraybuffer --enable-blink-feature=SharedArrayBuffer</code></p>
+
+<h2 id="Observações_de_compatibilidade">Observações de compatibilidade</h2>
+
+<p>[3] A especificação de compartilhamento de memória está sendo estabilizada. Anterior ao SpiderMonkey 48 {{geckoRelease(48)}}, a última API e semântica não foram implementadas ainda. As alterações entre as versões 46 e 48 do Firefox são:</p>
+
+<ul>
+ <li>Os métodos <code>Atomics.futexWakeOrRequeue()</code> e <code>Atomics.fence()</code> foram totalmente removidos ({{bug(1259544)}} e {{bug(1225028)}}).</li>
+ <li>O método {{jsxref("Atomics.wait()")}} e {{jsxref("Atomics.wake()")}} foram nomeados como <code>Atomics.futexWait()</code> e <code>Atomics.futexWake()</code> ({{bug(1260910)}}). Os nomes antigos foram mantidos como alias, e serão removidos na versão 49 ({{bug(1262062)}}).</li>
+ <li>As propriedades <code>Atomics.OK</code>, <code>Atomics.TIMEDOUT</code>, <code>Atomics.NOTEQUAL</code> foram removidas. O método {{jsxref("Atomics.wait()")}} agora retorna "ok", "timed-out" e "not-equal" ({{bug(1260835)}}).</li>
+ <li>
+  <p>O parâmetro <code>count</code> do método {{jsxref("Atomics.wake()")}} foi alterado: este agora possui o valor padrão <code>+Infinity</code>, e não <code>0</code> ({{bug(1253350)}}).</p>
+ </li>
+</ul>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typed arrays</a></li>
+ <li><a href="/en-US/docs/Web/API/Web_Workers_API">Web Workers</a></li>
+ <li><a href="https://github.com/lars-t-hansen/parlib-simple">parlib-simple </a>– a simple library providing synchronization and work distribution abstractions.</li>
+ <li><a href="https://github.com/tc39/ecmascript_sharedmem/blob/master/TUTORIAL.md">Shared Memory – a brief tutorial</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/bigint/index.html b/files/pt-br/web/javascript/reference/global_objects/bigint/index.html
new file mode 100644
index 0000000000..fc9cd37807
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/bigint/index.html
@@ -0,0 +1,240 @@
+---
+title: BigInt
+slug: Web/JavaScript/Reference/Global_Objects/BigInt
+translation_of: Web/JavaScript/Reference/Global_Objects/BigInt
+---
+<div>{{JSRef}}</div>
+
+<p><code>BigInt</code> é um objeto nativo que fornece um modo de representar números inteiros maiores que 2<sup>53</sup>, que é o maior número que o JavaScript consegue, com exatidão, representar com o tipo primitivo {{jsxref("Number")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush: js">BigInt(value);
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>O valor numérico do objeto que está sendo criado. Pode ser uma <em>string</em> ou um número inteiro.</dd>
+</dl>
+
+<div class="blockIndicator note">
+<p><strong>Observação</strong>: <code>BigInt()</code> não é usado com o operador {{jsxref("Operators/new", "new")}}.</p>
+</div>
+
+<dl>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Um <code>BigInt</code> é criado com a acrescentação de <code>n</code> ao final de um inteiro literal — <code>10n</code> — ou chamando a função <code>BigInt()</code>.</p>
+
+<pre class="brush: js">const theBiggestInt = 9007199254740991n;
+
+const alsoHuge = BigInt(9007199254740991);
+// ↪ 9007199254740991n
+
+const hugeString = BigInt("9007199254740991");
+// ↪ 9007199254740991n
+
+const hugeHex = BigInt("0x1fffffffffffff");
+// ↪ 9007199254740991n
+
+const hugeBin = BigInt("0b11111111111111111111111111111111111111111111111111111");
+// ↪ 9007199254740991n
+</pre>
+
+<p>Isso é parecido com um {{jsxref("Number")}} em algumas partes, mas difere-se em alguns assuntos importantes  — ele não pode ser usado com métodos no objeto {{jsxref("Math")}} e não pode ser misturado em operações ou qualquer instância de <code>Number</code>.</p>
+
+<div class="blockIndicator warning">
+<p>{{jsxref("Number")}} e <code>BigInt</code> não podem ser misturados em operações — eles devem ser manipulados com o mesmo tipo.</p>
+
+<p>Tenha cuidado com a conversão e desconversão de valores, visto que a precisão de <code>BigInt</code> pode ser perdida com a conversào para <code>Number</code>.</p>
+</div>
+
+<h3 id="Informações_do_tipo">Informações do tipo</h3>
+
+<p>Quando testado com <code>typeof</code> , um <code>BigInt</code> vai devolver "bigint":</p>
+
+<pre class="brush: js">typeof 1n === 'bigint'; // true
+typeof BigInt('1') === 'bigint'; // true
+</pre>
+
+<p>Quando envolvido em um <code>Object</code>, um <code>BigInt</code> vai ser considerado como um tipo normal de "object".</p>
+
+<pre class="brush: js">typeof Object(1n) === 'object'; // true
+</pre>
+
+<h3 id="Operadores">Operadores</h3>
+
+<p>Os seguintes operadores podem ser usados com <code>BigInt</code>s (ou com <code>BigInt</code>s envolvidos em objetos): <code>+</code>, `<code>*</code>`, `<code>-</code>`, `<code>**</code>`, `<code>%</code>` .</p>
+
+<pre class="brush: js">const previousMaxSafe = BigInt(Number.MAX_SAFE_INTEGER);
+// ↪ 9007199254740991
+
+const maxPlusOne = previousMaxSafe + 1n;
+// ↪ 9007199254740992n
+
+const theFuture = previousMaxSafe + 2n;
+// ↪ 9007199254740993n, isso funciona agora!
+
+const multi = previousMaxSafe * 2n;
+// ↪ 18014398509481982n
+
+const subtr = multi – 10n;
+// ↪ 18014398509481972n
+
+const mod = multi % 10n;
+// ↪ 2n
+
+const bigN = 2n ** 54n;
+// ↪ 18014398509481984n
+
+bigN * -1n
+// ↪ –18014398509481984n
+</pre>
+
+<p>O operador <code>/</code>  também funciona com o esperado com números inteiros. No entanto, desde que esses sejam <code>BigInt</code>s e não <code>BigDecimal</code>s, essa operação vai arredondar para 0, o que significa que não vai retornar qualquer valor fracional.</p>
+
+<div class="blockIndicator warning">
+<p>Uma operação com um resultado fracional será arredondado com <code>BigInt.</code></p>
+</div>
+
+<pre class="brush: js">const expected = 4n / 2n;
+// ↪ 2n
+
+const rounded = 5n / 2n;
+// ↪ 2n, e não 2.5n
+
+</pre>
+
+<h3 id="Comparações">Comparações</h3>
+
+<p>Um <code>BigInt</code> não é estritamente igual a um {{jsxref("Global_Objects/Number", "Number")}}, mas é mais ou menos assim.</p>
+
+<pre class="brush: js">0n === 0
+// ↪ false
+
+0n == 0
+// ↪ true</pre>
+
+<p>Um {{jsxref("Global_Objects/Number", "Number")}} e um <code>BigInt</code> podem ser comparado normalmente.</p>
+
+<pre class="brush: js">1n &lt; 2
+// ↪ true
+
+2n &gt; 1
+// ↪ true
+
+2 &gt; 2
+// ↪ false
+
+2n &gt; 2
+// ↪ false
+
+2n &gt;= 2
+// ↪ true</pre>
+
+<p>Eles podem ser misturados em <em>arrays</em> e sorteados.</p>
+
+<pre class="brush: js">const mixed = [4n, 6, -12n, 10, 4, 0, 0n];
+// ↪  [4n, 6, -12n, 10, 4, 0, 0n]
+
+mixed.sort();
+// ↪ [-12n, 0, 0n, 10, 4n, 4, 6]
+</pre>
+
+<p>Observe que comparações com <code>BigInt</code>s envolvidos em <code>Object</code> atuam com outros objetos, indicando somente a igualdade onde a mesma instância do objeto é comparada.</p>
+
+<pre class="brush: js">0n === Object(0n); // false
+Object(0n) === Object(0n); // false
+
+const o = Object(0n);
+o === o // true
+</pre>
+
+<h3 id="Conditionals">Conditionals</h3>
+
+<p>A <code>BigInt</code> behaves like a {{jsxref("Global_Objects/Number", "Number")}} in cases where it is converted to a {{jsxref("Global_Objects/Boolean", "Boolean")}}: via the {{jsxref("Global_Objects/Boolean", "Boolean")}} function; when used with logical operators {{jsxref("Operators/Logical_Operators", "Logical Operators")}}  <code>||</code>, `<code>&amp;&amp;</code>`, and <code>!</code>; or within a conditional test like an {{jsxref("Statements/if...else", "if statement")}}.</p>
+
+<pre class="brush: js">if (0n) {
+  console.log('Hello from the if!');
+} else {
+  console.log('Hello from the else!');
+}
+
+// ↪ "Hello from the else!"
+
+0n || 12n
+// ↪ 12n
+
+0n &amp;&amp; 12n
+// ↪ 0n
+
+Boolean(0n)
+// ↪ false
+
+Boolean(12n)
+// ↪ true
+
+!12n
+// ↪ false
+
+!0n
+// ↪ true
+</pre>
+
+<h2 id="Methods">Methods</h2>
+
+<dl>
+ <dt><strong><code>BigInt.asIntN()</code></strong></dt>
+ <dd>Wraps a BigInt between -2<sup>width-1</sup> and 2<sup>width-1</sup>-1</dd>
+ <dt><code>BigInt.asUintN()</code></dt>
+ <dd>Wraps a BigInt between 0 and 2<sup>width</sup>-1</dd>
+</dl>
+
+<h2 id="Properties">Properties</h2>
+
+<dl>
+ <dt>{{jsxref("BigInt.prototype")}}</dt>
+ <dd><span style="letter-spacing: -0.00278rem;">Allows the addition of properties to a </span><code style="letter-spacing: -0.00278rem;">BigInt</code><span style="letter-spacing: -0.00278rem;"> object.</span></dd>
+</dl>
+
+<h2 id="BigInt_instances"><code>BigInt</code> instances</h2>
+
+<p>All <code>BigInt</code> instances inherit from <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">BigInt.prototype</span></font>. The prototype object of the <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">BigInt</span></font> constructor can be modified to affect all <code>BigInt</code> instances.</p>
+
+<h3 id="Methods_2">Methods</h3>
+
+<p>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt/prototype', 'Methods')}}</p>
+
+<h2 id="Examples">Examples </h2>
+
+<h3 id="Calculating_Primes">Calculating Primes</h3>
+
+<pre class="brush: js">function isPrime(p) {
+  for (let i = 2n; i * i &lt;= p; i++) {
+    if (p % i === 0n) return false;
+  }
+  return true;
+}
+
+// Takes a BigInt as an argument and returns a BigInt
+function nthPrime(nth) {
+  let maybePrime = 2n;
+  let prime = 0n;
+
+  while (nth &gt;= 0n) {
+    if (isPrime(maybePrime)) {
+      nth -= 1n;
+      prime = maybePrime;
+    }
+    maybePrime += 1n;
+  }
+
+  return prime;
+}
+
+nthPrime(20n)
+// ↪ 73n</pre>
diff --git a/files/pt-br/web/javascript/reference/global_objects/bigint/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/bigint/prototype/index.html
new file mode 100644
index 0000000000..ff8de05541
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/bigint/prototype/index.html
@@ -0,0 +1,61 @@
+---
+title: BigInt.prototype
+slug: Web/JavaScript/Reference/Global_Objects/BigInt/prototype
+tags:
+  - BigInt
+  - JavaScript
+  - Propriedade
+  - Prototipo
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/BigInt/prototype
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>BigInt.prototype</code></strong> representa o protótipo para o  construtor {{JSxRef("BigInt")}} .</p>
+
+<p>{{JS_Property_Attributes(0, 0, 0)}}</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Todas instância de {{JSxRef("BigInt")}} herdam de <code>BigInt.prototype</code>. O objeto protótipo do construtor {{JSxRef("BigInt")}} pode ser modificado para afetar todas instâncias de {{JSxRef( "BigInt")}} .</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>BigInt.prototype.constructor</code></dt>
+ <dd>Retorna a função que cria instâncias deste objeto. Por padrão é o objeto<br>
+ {{JSxRef("BigInt")}}.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{JSxRef("BigInt.prototype.toLocaleString()")}}</dt>
+ <dd>Retorna uma string com uma representação sensível ao idioma para este número. Sobrescreve o método {{JSxRef("Object.prototype.toLocaleString()")}}<br>
+  </dd>
+ <dt>{{JSxRef("BigInt.prototype.toString()")}}</dt>
+ <dd>Retorna uma string respresentando o objeto específicado em um base específica. Sobrescreve o método {{JSxRef("Object.prototype.toString()")}} .</dd>
+ <dt>{{JSxRef("BigInt.prototype.valueOf()")}}</dt>
+ <dd>Retorna o valor primitivo de um objeto específicado. Sobrescreve o método {{JSxRef("Object.prototype.valueOf()")}}.</dd>
+</dl>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Estado</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-bigint.prototype', 'BigInt.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<p class="hidden">Para contribuir para este dado de compatibilidade, por favor escreva um pull resquest para este repositório: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.BigInt.prototype")}}</p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/boolean/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/index.html
new file mode 100644
index 0000000000..5d8f195d2f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/boolean/index.html
@@ -0,0 +1,194 @@
+---
+title: Boolean
+slug: Web/JavaScript/Reference/Global_Objects/Boolean
+tags:
+  - Boolean
+  - Constructor
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean
+---
+<div>{{JSRef}}</div>
+
+<p>O objeto <strong><code>Boolean</code></strong> é um objeto wrapper para um valor booleano.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>new Boolean([<var>value</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>Opcional. O valor inicial do objeto <code>Boolean.</code></dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O valor passado como primeiro parâmetro é convertido para um valor boleano, se necessário. Se o valor é omitido ou é <code>0</code>, <code>-0</code>, {{jsxref("null")}}, <code>false</code>, {{jsxref("NaN")}}, {{jsxref("undefined")}} ou é uma string vazia(<code>""</code>), o objeto terá um valor inicial de <code>false</code>. Todos outros valores, incluindo qualquer objeto ou string <code>"false"</code>,  criam um objeto com valor inicial  <code>true</code>.</p>
+
+<p>Não confunda os valores primitivos Boolean <code>true</code> e <code>false</code> com os valores <code>true</code> and <code>false</code> do objeto <code>Boolean</code>.</p>
+
+<p>Qualquer objeto cujo o valor não é {{jsxref("undefined")}} ou {{jsxref("null")}}, incluindo um objeto <code>Boolean</code> que o valor seja <code>false</code>, é avaliado para <code>true</code> quando passa por uma declaração condicional. Por exemplo, a condição a seguir {{jsxref("Statements/if...else", "if")}} a declaração é avaliada como <code>true</code>:</p>
+
+<pre class="brush: js">var x = new Boolean(false);
+if (x) {
+  // esse código é executado
+}
+</pre>
+
+<p>Esse comportamento não se aplica aos primitivos <code>Boolean</code>. Por exemplo, a condição a seguir {{jsxref("Statements/if...else", "if")}} a declaração é avaliada como <code>false</code>:</p>
+
+<pre class="brush: js">var x = false;
+if (x) {
+  // esse código não é executado
+}
+</pre>
+
+<p>Não use um objeto <code>Boolean</code> para converter um valor não-boleano para um valor boleano. Ao invés disso use <code>Boolean</code> como uma função para executar essa tarefa:</p>
+
+<pre class="brush: js">var x = Boolean(expression);     // preferido
+var x = new Boolean(expression); // não use
+</pre>
+
+<p>Se você especificar qualquer objeto, incluindo um objeto <code>Boolean</code> cujo valor é <code>false</code>, como valor inicial de um objeto <code>Boolean</code>, o novo objeto <code>Boolean</code> terá o valor de <code>true</code>.</p>
+
+<pre class="brush: js">var myFalse = new Boolean(false);   // valor inicial false
+var g = new Boolean(myFalse);       // valor inicial true
+var myString = new String('Hello'); // objeto String
+var s = new Boolean(myString);      // valor inicial true
+</pre>
+
+<p>Não use um um objeto <code>Boolean</code> no lugar de um primitivo B<code>oolean</code>.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>Boolean.length</code></dt>
+ <dd>Propriedade Length cujo valor é 1.</dd>
+ <dt>{{jsxref("Boolean.prototype")}}</dt>
+ <dd>Representa o protótipo para o construtor <code>Boolean</code>.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<p>O objeto global <code>Boolean</code> contém métodos próprios, entretanto,  ele herda alguns métodos através da cadeia de protótipos:</p>
+
+<h2 id="Instâncias_Boolean">Instâncias <code>Boolean</code></h2>
+
+<p>Todas instâncias <code>Boolean</code> herdam de {{jsxref("Boolean.prototype")}}. Assim como todos os construtores, o protótipo do objeto dita as propriedades e métodos herdados.</p>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Properties')}}</div>
+
+<h3 id="Métodos_2">Métodos</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Methods')}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Criando_objetos_Boolean_com_um_valor_inicial_false">Criando objetos <code>Boolean</code> com um valor inicial <code>false</code></h3>
+
+<pre class="brush: js">var bNoParam = new Boolean();
+var bZero = new Boolean(0);
+var bNull = new Boolean(null);
+var bEmptyString = new Boolean('');
+var bfalse = new Boolean(false);
+</pre>
+
+<h3 id="Criando_objetos_Boolean_com_um_valor_inicial_true">Criando objetos <code>Boolean</code> com um valor inicial <code>true</code></h3>
+
+<pre class="brush: js">var btrue = new Boolean(true);
+var btrueString = new Boolean('true');
+var bfalseString = new Boolean('false');
+var bSuLin = new Boolean('Su Lin');
+var bArrayProto = new Boolean([]);
+var bObjProto = new Boolean({});
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no Java Script 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.6', 'Boolean')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-boolean-objects', 'Boolean')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatIE("6.0")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Boolean.prototype")}}</li>
+ <li>{{Glossary("Boolean")}}</li>
+ <li><a href="http://en.wikipedia.org/wiki/Boolean_data_type">Boolean data type (Wikipedia)</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/boolean/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/prototype/index.html
new file mode 100644
index 0000000000..614272be40
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/boolean/prototype/index.html
@@ -0,0 +1,111 @@
+---
+title: Boolean.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Boolean/prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Boolean.prototype</code></strong> representa o prototype para o construtor de {{jsxref("Boolean")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Instancias de {{jsxref("Boolean")}} herdam de <code>Boolean.prototype</code>. Você pode usar os construtores do objeto prototype para adicionar propriedados ou metodos para todas as instancias de {{jsxref("Boolean")}} instances.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>Boolean.prototype.constructor</code></dt>
+ <dd>Retorna a função que criou a instancia do prototype. Esta é a função {{jsxref("Boolean")}} por padrão.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Boolean.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna a string contendo o codigo do objeto {{jsxref("Boolean")}} ;  pode-se usar esta string para criar um objeto equivalente. Sobreescreve o método {{jsxref("Object.prototype.toSource()")}}.</dd>
+ <dt>{{jsxref("Boolean.prototype.toString()")}}</dt>
+ <dd>Retorna uma string com valor <code>"true"</code> ou <code>"false"</code> dependendo qual o valor do objeto. Sobreescreve o método {{jsxref("Object.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("Boolean.prototype.valueOf()")}}</dt>
+ <dd>Retorna o valor primitivo do objeto {{jsxref("Boolean")}}. Sobreescreve o método {{jsxref("Object.prototype.valueOf()")}}.</dd>
+</dl>
+
+<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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementano no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.6.3.1', 'Boolean.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-boolean.prototype', 'Boolean.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/boolean/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/tosource/index.html
new file mode 100644
index 0000000000..5acf8e00fa
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/boolean/tosource/index.html
@@ -0,0 +1,96 @@
+---
+title: Boolean.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Boolean/toSource
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O método <code><strong>toSource()</strong></code> retorna uma representação string do código fonte do objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>booleanObj</var>.toSource()
+Boolean.toSource()</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>toSource</code> retorna os seguintes valores:</p>
+
+<ul>
+ <li>Para o objeto pré-construido {{jsxref("Boolean")}}, <code>toSource</code> retorna a seguinte string indicando que o código não está disponível:
+
+  <pre class="brush: js">function Boolean() {
+    [native code]
+}
+</pre>
+ </li>
+ <li>Para instancias de {{jsxref("Boolean")}}, <code>toSource</code> retorna a string representando o código fonte.</li>
+</ul>
+
+<p>Este método normalmente é chamando internamente pelo JavaScript e não explicitamente no código fonte.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não é parte de nenhum padrão. Implementado no Javascript 1.3.</p>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/boolean/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/tostring/index.html
new file mode 100644
index 0000000000..45820dc57d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/boolean/tostring/index.html
@@ -0,0 +1,128 @@
+---
+title: Boolean.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Boolean/toString
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/toString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>toString()</strong></code>  retorna uma string representando o objeto Boolean específico.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>bool</var>.toString()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string representando o objeto {{jsxref("Boolean")}} específico.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O objeto {{jsxref("Boolean")}} sobrepõe o método <code>toString</code> do objeto {{jsxref("Object")}}; ele não herda {{jsxref("Object.prototype.toString()")}}. Para objetos Boolean, o método <code>toString</code> retorna uma representação do objeto como string.</p>
+
+<p>O JavaScript chama o método <code>toString</code> automaticamente quando uma {{jsxref("Boolean")}} deve ser representado como texto ou quando uma {{jsxref("Boolean")}} é referenciada como uma concatenação de string.</p>
+
+<p>Para objetos e valores {{jsxref("Boolean")}}, o método nativo <code>toString</code> retorna a string  "<code>true</code>" ou "<code>false</code>", dependendo do valor do objeto boleano.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toString">Usando <code>toString</code></h3>
+
+<p>No código a seguir, <code>flag.toString()</code> retorna "<code>true</code>":</p>
+
+<pre class="brush: js">var flag = new Boolean(true);
+var myVar = flag.toString();
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.6.4.2', 'Boolean.prototype.toString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-boolean.prototype.tostring', 'Boolean.prototype.toString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/boolean/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/boolean/valueof/index.html
new file mode 100644
index 0000000000..e61d65033f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/boolean/valueof/index.html
@@ -0,0 +1,115 @@
+---
+title: Boolean.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf
+translation_of: Web/JavaScript/Reference/Global_Objects/Boolean/valueOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>valueOf()</strong></code> retorna o valor primitivo de um objeto {{jsxref("Boolean")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>bool</var>.valueOf()</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>valueOf do </code>{{jsxref("Boolean")}} retorna o valor primitivo de um objeto {{jsxref("Boolean")}} ou um literal {{jsxref("Boolean")}} como tipo de dado Boolean.</p>
+
+<p>Esse método é geralmente chamado internamente pelo JavaScript e não explicitamente no código.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_valueOf">Usando <code>valueOf</code></h3>
+
+<pre class="brush: js">x = new Boolean();
+myVar = x.valueOf(); // atribui o valor false à variável myVar
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Condição</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.6.4.3', 'Boolean.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-boolean.prototype.valueof', 'Boolean.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/dataview/index.html b/files/pt-br/web/javascript/reference/global_objects/dataview/index.html
new file mode 100644
index 0000000000..7f4974b123
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/dataview/index.html
@@ -0,0 +1,168 @@
+---
+title: DataView
+slug: Web/JavaScript/Reference/Global_Objects/DataView
+tags:
+  - Constructor
+  - DataView
+  - JavaScript
+  - TypedArrays
+translation_of: Web/JavaScript/Reference/Global_Objects/DataView
+---
+<div>{{JSRef}}</div>
+
+<p>O <strong><code>DataView</code></strong> provê uma interface de baixo nível para leitura e escrita de múltiplos tipos de número em um {{jsxref("ArrayBuffer")}}, independentemente da <a href="/pt-BR/docs/Glossario/Endianness">extremidade (<em>endianness</em>) da plataforma</a>.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/dataview-constructor.html")}}</p>
+
+<div class="hidden">
+<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">new DataView(buffer [, byteOffset [, byteLength]])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>buffer</code></dt>
+ <dd>{{jsxref("ArrayBuffer")}} ou {{jsxref("SharedArrayBuffer")}} {{experimental_inline}} existente para usar como armazenamento de um novo objeto <code>DataView</code>.</dd>
+ <dt><code>byteOffset</code> {{optional_inline}}</dt>
+ <dd>A mudança, em bytes, do primeiro byte determinado em um buffer, que será referenciado pela nova view. Se não for especificado, a view do buffer começará no primeiro byte.</dd>
+ <dt><code>byteLength</code> {{optional_inline}}</dt>
+ <dd>O número de elementos no array de bytes. Se não especificado, o tamanho da view será do mesmo tamanho do buffer.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um novo objeto <code>DataView</code> que representa o buffer de dados especificado. (Provavelmente não foi uma descrição muito útil.)</p>
+
+<p><font>Você pode pensar nesse objeto retornado como um "intérprete" de um array buffer de bytes - ele sabe como converter números para inserir em um buffer corretamente, tanto ao ler quanto ao gravar. </font><font>Isso significa lidar com conversões <em>integer,</em> <em>float,</em> <em>endianness</em> e outros detalhes da representação de números em formato binário.</font></p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<dl>
+ <dt><code>{{jsxref("RangeError")}}</code></dt>
+ <dd>Lançado se o <code>byteOffset</code> ou <code>byteLength</code> especificados ultrapassarem o final do buffer.</dd>
+ <dd><font><font>Por exemplo, se o buffer tem 16 bytes de comprimento, o </font></font><code>byteOffset</code> <font><font>é 8 e o </font></font><code>byteLength</code> <font><font>é 10, esse erro será lançado porque a view resultante tenta estender 2 bytes acima do comprimento total do buffer.</font></font></dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<h3 id="Endianness"><em>Endianness</em></h3>
+
+<p>Formatos de números <em>Multi-byte</em> são representados de maneira diferente na memória, dependendo da arquitetura da máquina, veja {{Glossary("Endianness")}} para mais informações. Assessores de <code>DataView</code> fornecem controle explícito de como o dado será acessado, independente do <em>endianness </em>da arquitetura em execução. </p>
+
+<pre class="brush: js">var littleEndian = (function() {
+  var buffer = new ArrayBuffer(2);
+  new DataView(buffer).setInt16(0, 256, true /* littleEndian */);
+  // Int16Array uses the platform's endianness.
+  return new Int16Array(buffer)[0] === 256;
+})();
+console.log(littleEndian); // true or false
+</pre>
+
+<h3 id="Valores_inteiros_de_64_bits"><font><font>Valores inteiros de 64 bits</font></font></h3>
+
+<p>Como JavaScript atualmente não inclui suporte padrão para valores inteiros de 64 bits, <code>DataView</code> não oferece operações nativas de 64 bits. Como solução alternativa, você poderia implementar sua própria função getUint64() para obter um valor com a precisão de {{jsxref("Number.MAX_SAFE_INTEGER")}}, o que pode ser bom para determinados casos.</p>
+
+<pre class="brush: js">function getUint64(dataview, byteOffset, littleEndian) {
+  // split 64-bit number into two 32-bit (4-byte) parts
+  const left =  dataview.getUint32(byteOffset, littleEndian);
+  const right = dataview.getUint32(byteOffset+4, littleEndian);
+
+  // combine the two 32-bit values
+  const combined = littleEndian? left + 2**32*right : 2**32*left + right;
+
+  if (!Number.isSafeInteger(combined))
+    console.warn(combined, 'exceeds MAX_SAFE_INTEGER. Precision may be lost');
+
+  return combined;
+}</pre>
+
+<p>Como alternativa, se você precisar de um intervalo completo de 64 bits, poderá criar um {{jsxref("BigInt")}}.</p>
+
+<pre class="brush: js">function getUint64BigInt(dataview, byteOffset, littleEndian) {
+  // split 64-bit number into two 32-bit (4-byte) parts
+  const left = dataview.getUint32(byteOffset, littleEndian);
+  const right = dataview.getUint32(byteOffset + 4, littleEndian);
+
+  // combine the two 32-bit values as their hex string representations
+  const combined = littleEndian ?
+    right.toString(16) + left.toString(16).padStart(8, '0') :
+    left.toString(16) + right.toString(16).padStart(8, '0');
+
+  return BigInt(`0x${combined}`);
+}
+</pre>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<p>Todas as instâncias de <code>DataView</code> herdam {{jsxref("DataView.prototype")}} e permitem a adição de propriedades a todos os objetos DataView.</p>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Properties')}}</p>
+
+<h2 id="Métodos">Métodos</h2>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/DataView/prototype','Methods')}}</p>
+
+<h2 id="Exemplo">Exemplo</h2>
+
+<pre class="brush: js">var buffer = new ArrayBuffer(16);
+var dv = new DataView(buffer, 0);
+
+dv.setInt16(1, 42);
+dv.getInt16(1); //42
+</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('Typed Array')}}</td>
+   <td>{{Spec2('Typed Array')}}</td>
+   <td>Substituído pelo ECMAScript 6</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-dataview-constructor', 'DataView')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial no ECMA standard</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-dataview-constructor', 'DataView')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<div class="hidden">
+<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>and send us a pull request.</p>
+</div>
+
+<p>{{Compat("javascript.builtins.DataView")}}</p>
+
+<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
+
+<p>Começando com o Firefox 40, <code>DataView</code> deve ser construído com o operador {{jsxref("Operators/new", "new")}} . Chamando <code>DataView()</code> como uma função sem o <code>new</code>,  irá lançar um {{jsxref("TypeError")}} de agora em diante.</p>
+
+<pre class="brush: js example-bad">var dv = DataView(buffer, 0);
+// TypeError: calling a builtin DataView constructor without new is forbidden</pre>
+
+<pre class="brush: js example-good">var dv = new DataView(buffer, 0);</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a class="link-https" href="https://github.com/jDataView/jDataView">jDataView</a>: Biblioteca javascript que faz o polyfill e extende a API do <code>DataView</code> para todos os browsers e para o Node.js.</li>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li>{{jsxref("SharedArrayBuffer")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/@@toprimitive/index.html b/files/pt-br/web/javascript/reference/global_objects/date/@@toprimitive/index.html
new file mode 100644
index 0000000000..bc2c7b5f35
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/@@toprimitive/index.html
@@ -0,0 +1,77 @@
+---
+title: 'Date.prototype[@@toPrimitive]'
+slug: Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/@@toPrimitive
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>[@@toPrimitive]()</strong></code> converte o objeto <code>Date</code> para um valor primitivo.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>Date()[Symbol.toPrimitive](hint);
+</var></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O valor primitivo do objeto {{jsxref("Date")}}. Dependendo do argumento, o método pode retornar uma cadeia de caracteres (<em>string</em>) ou um número.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>[@@toPrimitive]()</code> do objeto {{jsxref("Date")}} retorna um valor primitivo, que pode ser tanto um tipo numérico quanto uma string.</p>
+
+<p>Se <code>hint</code> é <code>"string"</code> ou <code>"default"</code>, <code>[@@toPrimitive]()</code> tenta chamar o método {{jsxref("Object.prototype.toString()", "toString")}}. Se a propriedade <code>toString</code> não existe, ele tenta chamar o método {{jsxref("Object.prototype.valueOf()", "valueOf")}} e se o <code>valueOf</code> não existir, <code>[@@toPrimitive]()</code> joga um {{jsxref("TypeError")}}.</p>
+
+<p>Se <code>hint</code> é <code>"number"</code>, <code>[@@toPrimitive]()</code> tenta primeiro chamar <code>valueOf</code>, e se ele falha, chama <code>toString</code>.</p>
+
+<p>O JavaScript chama o método <code>[@@toPrimitive]()</code> para converter um objeto para um valor primitivo. Você raramente precisa invocar o método <code>[@@toPrimitive]()</code> em si; JavaScript automaticamente o invoca quando encontra um objeto onde um valor primitivo é esperado.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Retornando_primitivos_de_data">Retornando primitivos de data</h3>
+
+<pre class="brush: js notranslate">const testDate = new Date(1590757517834);
+// "Date Fri May 29 2020 14:05:17 GMT+0100 (British Summer Time)"
+
+testDate[Symbol.toPrimitive]('string');
+// Returns "Date Fri May 29 2020 14:05:17 GMT+0100 (British Summer Time)"
+
+testDate[Symbol.toPrimitive]('number');
+// Returns "1590757517834"
+
+testDate[Symbol.toPrimitive]('default');
+// Returns "Date Fri May 29 2020 14:05:17 GMT+0100 (British Summer Time)"</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype-@@toprimitive', 'Date.prototype.@@toPrimitive')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.@@toPrimitive")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Symbol.toPrimitive")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getdate/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getdate/index.html
new file mode 100644
index 0000000000..0e4244c42d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getdate/index.html
@@ -0,0 +1,127 @@
+---
+title: Date.prototype.getDate()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getDate
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDate
+---
+<div>{{JSRef("Global_Objects", "Date")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong><code>getDate()</code></strong> retorna o dia do mês da data especificada de acordo com a hora local.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getDate()</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h3 id="Returns" name="Returns">Retorna</h3>
+
+<p>O valor retornado por <code>getDate()</code> é um inteiro entre 1 e 31.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_getDate" name="Example:_Using_getDate">Exemplo: Usando <code>getDate()</code></h3>
+
+<p>O segundo statement abaixo atribui o valor 25 à variável day, baseado no valor do objeto {{jsxref("Global_Objects/Date", "Date")}} <span style="font-family: courier,andale mono,monospace;">Xmas95</span>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30');
+var day = Xmas95.getDate();
+
+console.log(day); // 25
+</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>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial. Implementado em JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.14', 'Date.prototype.getDate')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getdate', 'Date.prototype.getDate')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
+ <li>{{jsxref("Date.prototype.setDate()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getday/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getday/index.html
new file mode 100644
index 0000000000..594f2aa427
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getday/index.html
@@ -0,0 +1,127 @@
+---
+title: Date.prototype.getDay()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getDay
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getDay
+---
+<div>{{JSRef("Global_Objects", "Date")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong><code>getDay()</code></strong> retorna o dia da semana para a data especificada de acordo com a hora local, onde 0 representa o Domingo.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getDay()</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h3 id="Returns" name="Returns">Retorna</h3>
+
+<p>O valor retornado por <code>getDay()</code> é um inteiro que corresponde com o dia da semana: 0 para Domingo, 1 para Segunda-Feira, 2 para Terça-Feira, e assim por diante.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_getDay" name="Example:_Using_getDay">Exemplo: Usando <code>getDay()</code></h3>
+
+<p>O segundo statement abaixo atribui o valor 1 à variável weekday (dia da semana), baseado no valor do objeto {{jsxref("Global_Objects/Date", "Date")}} <code>Xmas95</code>. A data 25 de Dezembro de 1995 é uma Segunda-Feira.</p>
+
+<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30');
+var weekday = Xmas95.getDay();
+
+console.log(weekday); // 1
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Especificação</strong></th>
+   <th scope="col">Status</th>
+   <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Comentário</strong></th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td><span style="background-color: rgba(212, 221, 228, 0.14902);">Definição inicial. Implementado em JavaScript 1.0.</span></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.16', 'Date.prototype.getDay')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getday', 'Date.prototype.getDay')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
+ <li>{{jsxref("Date.prototype.setDate()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getfullyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getfullyear/index.html
new file mode 100644
index 0000000000..140fca67d4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getfullyear/index.html
@@ -0,0 +1,127 @@
+---
+title: Date.prototype.getFullYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getFullYear
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getFullYear
+---
+<div>{{JSRef("Global_Objects", "Date")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong><code>getFullYear()</code></strong> retorna o ano da data especificada de acordo com a hora local.</p>
+
+<p>Use este método ao invés do {{jsxref("Date.prototype.getYear()", "getYear()")}}.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getFullYear()</code></pre>
+
+<h3 id="Parameters" name="Parameters" style="font-size: 1.71428571428571rem;">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h3 id="Returns" name="Returns">Retorna</h3>
+
+<p>O valor retornado por <code>getFullYear()</code> é um número absoluto. Para datas entre os anos 1000 e 9999, <code>getFullYear()</code> retorna um número de quatro dígitos, por exemplo, 1995. Use esta função para ter certeza de que o ano é compatível com os anos depois de 2000.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_getFullYear" name="Example:_Using_getFullYear">Exemplo: Usando <code>getFullYear()</code></h3>
+
+<p>O exemplo seguinte atribui o valor de quatro dígitos do ano corrente à variável year.</p>
+
+<pre class="brush: js">var today = new Date();
+var year = today.getFullYear();
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Especificação</strong></th>
+   <th scope="col">Status</th>
+   <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Comentário</strong></th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td><span style="background-color: rgba(212, 221, 228, 0.14902);">Definição inicial. Implementado em JavaScript </span>1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.10', 'Date.prototype.getFullYear')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getfullyear', 'Date.prototype.getFullYear')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.getYear()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/gethours/index.html b/files/pt-br/web/javascript/reference/global_objects/date/gethours/index.html
new file mode 100644
index 0000000000..49c79ae5ae
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/gethours/index.html
@@ -0,0 +1,126 @@
+---
+title: Date.prototype.getHours()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getHours
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getHours
+---
+<div>{{JSRef("Global_Objects", "Date")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong><code>getHours()</code></strong> retorna a hora para a data especificada, de acordo com a hora local.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getHours()</code></pre>
+
+<h3 id="Parameters" name="Parameters" style="font-size: 1.71428571428571rem;">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h3 id="Returns" name="Returns">Retorna</h3>
+
+<p>O valor retornado por <code>getHours()</code> é um inteiro entre 0 e 23.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_getHours" name="Example:_Using_getHours">Exemplo: Usando <code>getHours()</code></h3>
+
+<p>O segundo statement abaixo atribui o valor 23 à variável <code>hours</code>, baseado no valor do objeto {{jsxref("Global_Objects/Date", "Date")}} <code>Xmas95</code>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30');
+var hours = Xmas95.getHours();
+
+console.log(hours); // 23
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Especificação</strong></th>
+   <th scope="col">Status</th>
+   <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif; font-weight: bold;">Comentário</strong></th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td><span style="background-color: rgba(212, 221, 228, 0.14902);">Definição inicial. Implementado em JavaScript </span>1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.18', 'Date.prototype.getHours')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.gethours', 'Date.prototype.getHours')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCHours()")}}</li>
+ <li>{{jsxref("Date.prototype.setHours()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getmilliseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getmilliseconds/index.html
new file mode 100644
index 0000000000..4bbd37b571
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getmilliseconds/index.html
@@ -0,0 +1,117 @@
+---
+title: Date.prototype.getMilliseconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMilliseconds
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getMilliseconds()</code></strong> retorna os milissegundos em uma data específica de acordo com o horário local.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getMilliseconds()</code></pre>
+
+<h3 id="Retorna">Retorna</h3>
+
+<p>Um número, entre 0 e 999, representando os milissegundos de uma data de acordo com o horário local.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_getMilliseconds()">Usando o <code>getMilliseconds()</code></h3>
+
+<p>O exemplo a seguir atribui a porção de milissegundos do horário atual à variável <code>milliseconds</code>:</p>
+
+<pre class="brush: js">var today = new Date();
+var milliseconds = today.getMilliseconds();
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.24', 'Date.prototype.getMilliseconds')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getmilliseconds', 'Date.prototype.getMilliseconds')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getminutes/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getminutes/index.html
new file mode 100644
index 0000000000..c053d864c4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getminutes/index.html
@@ -0,0 +1,121 @@
+---
+title: Date.prototype.getMinutes()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getMinutes
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMinutes
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getMinutes()</code></strong> retorna os minutos em uma data específica de acordo com o horário local.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getMinutes()</code></pre>
+
+<h3 id="Retorna">Retorna</h3>
+
+<p>Um número inteiro, entre 0 e 59, representando os minutos em uma data de acordo com o horário local.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_getMinutes()">Usando o <code>getMinutes()</code></h3>
+
+<p>The second statement below assigns the value 15 to the variable <code>minutes</code>, based on the value of the {{jsxref("Global_Objects/Date", "Date")}} object <code>Xmas95</code>.</p>
+
+<p>No exemplo abaixo, a segunda linha atribui o valor 15 à variável <code>minutes</code>, baseado no valor de objeto {{jsxref("Global_Objects/Date")}} <code>Xmas95</code>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30');
+var minutes = Xmas95.getMinutes();
+
+console.log(minutes); // 15
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.20', 'Date.prototype.getMinutes')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getminutes', 'Date.prototype.getMinutes')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li>
+ <li>{{jsxref("Date.prototype.setMinutes()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getmonth/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getmonth/index.html
new file mode 100644
index 0000000000..9685a3a383
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getmonth/index.html
@@ -0,0 +1,121 @@
+---
+title: Date.prototype.getMonth()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getMonth
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getMonth
+---
+<div>{{JSRef}}</div>
+
+<div> </div>
+
+<p>O método <strong><code>getMonth()</code></strong> retorna o mês na data especificada de acordo com o horário local, como um valor zero-based (onde o zero indica o primeiro mês do ano).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getMonth()</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>O valor retornado pelo método <code>getMonth()</code> é um inteiro entre 0 e 11. 0 corresponde a Janeiro, 1 a Fevereiro, e assim sucessivamente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_getMonth()">Usando o <code>getMonth()</code></h3>
+
+<p>A segunda declaração abaixo atribui o valor 11 à variavel <code>month</code>,  baseado no valor do objeto {{jsxref("Date")}} <code>Xmas95</code>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30');
+var month = Xmas95.getMonth();
+
+console.log(month); // 11
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.12', 'Date.prototype.getMonth')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getmonth', 'Date.prototype.getMonth')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also"><br>
+ Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li>
+ <li>{{jsxref("Date.prototype.setMonth()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getseconds/index.html
new file mode 100644
index 0000000000..4d4aa2b8c2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getseconds/index.html
@@ -0,0 +1,121 @@
+---
+title: Date.prototype.getSeconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getSeconds
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getSeconds
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getSeconds()</code></strong> retorna os segundos de uma data específica de acordo com o horário local.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getSeconds()</code></pre>
+
+<h3 id="Retorna">Retorna</h3>
+
+<p>Um número inteiro, entre 0 e 59, representando os segundos de uma data específica de acordo com o horário local.</p>
+
+<h2 id="Exemples">Exemples</h2>
+
+<h3 id="Usando_o_getSeconds()">Usando o <code>getSeconds()</code></h3>
+
+<p>The second statement below assigns the value 30 to the variable <code>seconds</code>, based on the value of the {{jsxref("Global_Objects/Date", "Date")}} object <code>Xmas95</code>.</p>
+
+<p>No exemplo a seguir, a segunda linha atribui o valor 30 à variável <code>seconds</code>, baseado no valor do objeto {{jsxref("Global_Objects/Date", "Date")}} <code>Xmas95</code>.</p>
+
+<pre class="brush: js">var Xmas95 = new Date('December 25, 1995 23:15:30');
+var seconds = Xmas95.getSeconds();
+
+console.log(seconds); // 30
+</pre>
+
+<h2 id="Espeficicações">Espeficicaçõ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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.22', 'Date.prototype.getSeconds')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getseconds', 'Date.prototype.getSeconds')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suport básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setSeconds()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/gettime/index.html b/files/pt-br/web/javascript/reference/global_objects/date/gettime/index.html
new file mode 100644
index 0000000000..15bf8855fb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/gettime/index.html
@@ -0,0 +1,137 @@
+---
+title: Date.prototype.getTime()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getTime
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTime
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getTime()</code></strong> retorna o valor numérico correspondente ao horário da data especificada de acordo com o horário universal.</p>
+
+<p>Você pode usar este método para atribuir uma data e horário a outro objeto {{jsxref("Date")}}. Este método é funcionalmente equivalente ao método {{jsxref("Date.valueof", "valueOf()")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getTime()</code></pre>
+
+<h3 id="Retorna">Retorna</h3>
+
+<p>Um número representando os milissegundos passados entre 1 de Janeiro de 1970 00:00:00 UTC e a data atual.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getTime()_para_duplicar_datas">Usando <code>getTime()</code> para duplicar datas</h3>
+
+<p>Construindo um objeto de data com um horário idêntico.</p>
+
+<pre class="brush: js">// Sendo o mês iniciado em zero, birthday será 10 de Janeiro de 1995
+var birthday = new Date(1994, 12, 10);
+var copy = new Date();
+copy.setTime(birthday.getTime());
+</pre>
+
+<h3 id="Medindo_tempo_de_execução">Medindo tempo de execução</h3>
+
+<p>Subtrair duas chamadas subsequentes a <code>getTime()</code> em objetos {{jsxref("Date")}} recém criados resultará no intervalo de tempo entre essas duas chamadas. Isso pode ser usado para calcular o tempo de execução de algumas operações. Veja também {{jsxref("Date.now()")}} para evitar instanciar objetos {{jsxref("Date")}} desnecessariamente.</p>
+
+<pre class="brush: js">var end, start;
+
+start = new Date();
+for (var i = 0; i &lt; 1000; i++) {
+  Math.sqrt(i);
+}
+end = new Date();
+
+console.log('Operation took ' + (end.getTime() - start.getTime()) + ' msec');
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.9', 'Date.prototype.getTime')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.gettime', 'Date.prototype.getTime')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.setTime()")}}</li>
+ <li>{{jsxref("Date.prototype.valueOf()")}}</li>
+ <li>{{jsxref("Date.now()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html b/files/pt-br/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html
new file mode 100644
index 0000000000..2a10c9b6d6
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/gettimezoneoffset/index.html
@@ -0,0 +1,107 @@
+---
+title: Date.prototype.getTimezoneOffset()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getTimezoneOffset
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getTimezoneOffset()</code></strong> retorna a diferença, em minutos, do deslocamento de fuso horário entre o UTC (Tempo Universal Coordenado) e a localidade atual.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getTimezoneOffset()</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p>Nenhum</p>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O deslocamento de fuso horário é a diferença, em minutos, entre o UTC (Tempo Universal Coordenado) e o horário local. Perceba que isto significa que o deslocamento será negativo se o fuso horário local está à direita do UTC e positivo se está a esquerda. Por exemplo, se seu fuso horário é UTC+10(Padrão da Austrália Oriental), -600 será retornado. O Horário de verão evita que este valor seja sempre o mesmo para uma determinada localidade.</p>
+
+<p>Exemplo</p>
+
+<h3 id="Utilizando_getTimezoneOffset()">Utilizando <code>getTimezoneOffset()</code></h3>
+
+<pre class="brush: js">var x = new Date();
+var currentTimeZoneOffsetInHours = x.getTimezoneOffset() / 60;
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.26', 'Date.prototype.getTimezoneOffset')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.gettimezoneoffset', 'Date.prototype.getTimezoneOffset')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcdate/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcdate/index.html
new file mode 100644
index 0000000000..8b370ec07d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcdate/index.html
@@ -0,0 +1,118 @@
+---
+title: Date.prototype.getUTCDate()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDate
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getUTCDate()</code></strong> retorna o dia (data) do mês na data especificada de acordo com o horário universal.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCDate()</code></pre>
+
+<h3 id="Retorna">Retorna</h3>
+
+<p>Um número inteiro, entre 1 e 31, representando o dia do mês na data especificada de acordo com o horário universal.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getUTCDate()">Usando <code>getUTCDate()</code></h3>
+
+<p>O exemplo a seguir atribui o dia da data atual à variável <code>day</code>:</p>
+
+<pre class="brush: js">var today = new Date();
+var day = today.getUTCDate();
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.15', 'Date.prototype.getUTCDate')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcdate', 'Date.prototype.getUTCDate')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getDate()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCDay()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCDate()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcday/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcday/index.html
new file mode 100644
index 0000000000..d7eb82b8b4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcday/index.html
@@ -0,0 +1,117 @@
+---
+title: Date.prototype.getUTCDay()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCDay
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getUTCDay()</code></strong> retorna o dia da semana na data especificada de acordo com o horário universal, onde 0 representa domingo.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.getUTCDay()</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O valor retornado por <code>getUTCDay()</code> é um inteiro correspondente ao dia da semana: 0 para domingo, 1 para segunda-feira, 2 para terça-feira e assim por diante.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getUTCDay">Usando <code>getUTCDay()</code></h3>
+
+<p>O exemplo a seguir atribui a parte do dia da semana da data atual à variável <code>diaDaSemana</code>.</p>
+
+<pre class="brush: js notranslate">var hoje = new Date();
+var <code>diaDaSemana</code> = hoje.getUTCDay();
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.17', 'Date.prototype.getUTCDay')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getutcday', 'Date.prototype.getUTCDay')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
+ <li>{{jsxref("Date.prototype.getDay()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCDate()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcfullyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcfullyear/index.html
new file mode 100644
index 0000000000..4c6788fc72
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcfullyear/index.html
@@ -0,0 +1,81 @@
+---
+title: Date.prototype.getUTCFullYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCFullYear
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getUTCFullYear()</code></strong> retorna o ano na data indicada de acordo com o horário universal.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-getutcfullyear.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCFullYear()</code></pre>
+
+<h3 id="Retorna">Retorna</h3>
+
+<p>Um número que representa o ano na data indicada de acordo com o horário universal.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O valor retornado por <code>getUTCFullYear()</code> é um número absoluto compatível com ano 2000, por exemplo, 1995.</p>
+
+<h2 id="Exemplos"> Exemplos</h2>
+
+<h3 id="Usando_getUTCFullYear()">Usando <code>getUTCFullYear()</code></h3>
+
+<p>O exemplo a seguir atribui o valor de 4 dígitos do ano atual à variável <code>year.</code></p>
+
+<pre class="brush: js">var today = new Date();
+var year = today.getUTCFullYear();
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>
+    <p>Definição inicial. Implementado no JavaScript 1.3.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.11', 'Date.prototype.getUTCFullYear')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcfullyear', 'Date.prototype.getUTCFullYear')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.getUTCFullYear")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutchours/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutchours/index.html
new file mode 100644
index 0000000000..7f962f722e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getutchours/index.html
@@ -0,0 +1,63 @@
+---
+title: Date.prototype.getUTCHours()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours
+tags:
+  - Date
+  - JavaScript
+  - Prototipo
+  - Prototype
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCHours
+---
+<div>{{JSRef}}</div>
+
+<div>O método <strong><code>getUTCHours()</code></strong> retorna o número de horas na data especificada de acordo com o horário universal (UTC).</div>
+
+<p>{{EmbedInteractiveExample("pages/js/date-getutchours.html")}}</p>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.getUTCHours()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um número inteiro, entre 0 e 23, representando as horas em uma data de acordo com o horário universal (UTC).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getUTCHours">Usando <code>getUTCHours()</code></h3>
+
+<p>O exemplo a seguir atribui a porção de horas do horário corrente à variável <code>hours</code>.</p>
+
+<pre class="brush: js notranslate">var today = new Date();
+var hours = today.getUTCHours();
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutchours', 'Date.prototype.getUTCHours')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.getUTCHours")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getHours()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html
new file mode 100644
index 0000000000..9f9fd540bf
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcmilliseconds/index.html
@@ -0,0 +1,77 @@
+---
+title: Date.prototype.getUTCMilliseconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMilliseconds
+---
+<div>{{JSRef}}</div>
+
+<p>o método <strong><code>getUTCMilliseconds()</code></strong> retorna os milisegundos na data especificada, de acordo com o horário universal (UTC).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMilliseconds()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um número inteiro, entre 0 e 999, representando os milisegundos na data especificada de acordo com o horário universal (UTC).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getUTCMilliseconds()">Usando <code>getUTCMilliseconds()</code></h3>
+
+<p>O exemplo a seguir associa a parte dos milissegundos do tempo atual à variável <code>milissegundos</code>.</p>
+
+<pre class="brush: js">var hoje = new Date();
+var <code>milissegundos </code>= today.getUTCMilliseconds();
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>definição inicial. Implementado no JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.25', 'Date.prototype.getUTCMilliseconds')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcmilliseconds', 'Date.prototype.getUTCMilliseconds')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.getUTCMilliseconds")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcminutes/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcminutes/index.html
new file mode 100644
index 0000000000..98eaee648d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcminutes/index.html
@@ -0,0 +1,62 @@
+---
+title: Date.prototype.getUTCMinutes()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes
+tags:
+  - Date
+  - JavaScript
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMinutes
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getUTCMinutes()</code></strong> retorna os minutos na data especificada de acordo com o tempo universal.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-getutcminutes.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.getUTCMinutes()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um número inteiro, entre 0 e 59, representando os minutos na data especificada de acordo com o horário universal (UTC).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getUTCMinutes">Usando <code>getUTCMinutes()</code></h3>
+
+<p>O seguinte exemplo atribui a parte dos minutos do tempo atual para a variável <code>minutes</code>.</p>
+
+<pre class="brush: js notranslate">var today = new Date();
+var minutes = today.getUTCMinutes();
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcminutes', 'Date.prototype.getUTCMinutes')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.getUTCMinutes")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMinutes()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcmonth/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcmonth/index.html
new file mode 100644
index 0000000000..9eeed116d8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcmonth/index.html
@@ -0,0 +1,77 @@
+---
+title: Date.prototype.getUTCMonth()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth
+tags:
+  - Design
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCMonth
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>getUTCMonth()</code></strong> retorna o mês da data especificada de acordo com o horário universal, como um valor iniciado em zero (aonde zero indica o primeiro mês do ano).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCMonth()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um número inteiro, entre 0 e 11, correspondente ao mês da data informada de acordo com o horário universal. 0 para Janeiro, 1 para Fevereiro, 2 para Março, e assim em diante.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getUTCMonth()">Usando <code>getUTCMonth()</code></h3>
+
+<p>O exemplo a seguir atribui a parte do mês da data atual a variável <code>month</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var month = today.getUTCMonth();
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.13', 'Date.prototype.getUTCMonth')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcmonth', 'Date.prototype.getUTCMonth')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.getUTCMonth")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMonth()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getutcseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getutcseconds/index.html
new file mode 100644
index 0000000000..40b747c1cb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getutcseconds/index.html
@@ -0,0 +1,75 @@
+---
+title: Date.prototype.getUTCSeconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getUTCSeconds
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>getUTCSeconds()</code></strong> retorna os segundos na data informada de acordo com a hora universal.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-getutcseconds.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getUTCSeconds()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um número inteiro, entre 0 e 59, representando os segundos da data informada de acordo com a hora universal.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getUTCSeconds()">Usando <code>getUTCSeconds()</code></h3>
+
+<p>The following example assigns the seconds portion of the current time to the variabl</p>
+
+<p>O exemplo a seguir atribui a parte dos segundos da hora atual à variável <code>seconds</code>.</p>
+
+<pre class="brush: js">var today = new Date();
+var seconds = today.getUTCSeconds();
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.23', 'Date.prototype.getUTCSeconds')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.getutcseconds', 'Date.prototype.getUTCSeconds')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.getUTCSeconds")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getSeconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/getyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/getyear/index.html
new file mode 100644
index 0000000000..47ece39f41
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/getyear/index.html
@@ -0,0 +1,169 @@
+---
+title: Date.prototype.getYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/getYear
+tags:
+  - Date
+  - Deprecated
+  - JavaScript
+  - Method
+  - Prototype
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/getYear
+---
+<div>{{JSRef("Global_Objects", "Date")}} {{deprecated_header}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong><code>getYear()</code></strong> retorna o ano especificado pela data de acordo com a hora local. Por conta do fato de que <code>getYear()</code> não retorna anos completos ("problema do ano 2000"), este método não é mais utilizado e foi substituido pelo método {{jsxref("Date.prototype.getFullYear", "getFullYear()")}}.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.getYear()</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h3 id="Returns" name="Returns">Retorna</h3>
+
+<p>O método <code>getYear()</code> retorna o ano menos 1900; então:</p>
+
+<ul>
+ <li>Para ano maior ou igual a 2000, o valor retornado por <code>getYear()</code> é 100 ou mais. Por exemplo, se o ano for 2026, <code>getYear()</code> retorna 126.</li>
+ <li>Para ano entre e incluindo 1900 e 1999, o valor retornado por <code>getYear()</code> é entre 0 e 99. Por exemplo, se o anor for 1976, <code>getYear()</code> retorna 76.</li>
+ <li>Para ano menor que 1900, o valor retornado por <code>getYear()</code> é menor que 0. Por exemplo, se o ano for 1800, <code>getYear()</code> retorna -100.</li>
+</ul>
+
+<p>Para levar em consideração anos antes e depois de 2000, você deve utilizar {{jsxref("Date.prototype.getFullYear", "getFullYear()")}} ao invés de <code>getYear()</code> para que o ano seja especificado por completo.</p>
+
+<h2 id="Backward_compatibility" name="Backward_compatibility">Retrocombatibilidade</h2>
+
+<h3 id="JavaScript_1.2_and_earlier" name="JavaScript_1.2_and_earlier">Comportamento em JavaScript 1.2 e anteriores</h3>
+
+<p>O método <code>getYear()</code> retorna um ano de 2 ou 4 dígitos:</p>
+
+<ul>
+ <li>Para anos entre e incluindo 1900 e 1999, o valor retornado por <code>getYear()</code> é o ano menos 1900. Por exemplo, se o ano é 1976, o valor retornado é 76.</li>
+ <li>Para anos menores que 1900 ou maiores que 1999, o valor retornado por <code>getYear()</code> é um ano de 4 dígitos. Por exemplo, se o ano é 1856, o valor retornado é 1856. Se o ano é 2026, o valor retornado é 2026.</li>
+</ul>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Years_between_1900_and_1999" name="Example:_Years_between_1900_and_1999">Exemplo: Anos entre 1900 e 1999</h3>
+
+<p>O segundo statement atribui o valor 95 à variável <code>year</code>.</p>
+
+<pre class="brush: js">var Xmas = new Date('December 25, 1995 23:15:00');
+var year = Xmas.getYear(); // returns 95
+</pre>
+
+<h3 id="Example:_Years_above_1999" name="Example:_Years_above_1999">Exemplo: Anos depois de 1999</h3>
+
+<p>O segundo statement atribui o valor 100 à variável <code>year</code>.</p>
+
+<pre class="brush: js">var Xmas = new Date('December 25, 2000 23:15:00');
+var year = Xmas.getYear(); // returns 100
+</pre>
+
+<h3 id="Example:_Years_below_1900" name="Example:_Years_below_1900">Exemplo: Anos antes de 1900</h3>
+
+<p>O segundo statement atribui o valor  -100 à variável <code>year</code>.</p>
+
+<pre class="brush: js">var Xmas = new Date('December 25, 1800 23:15:00');
+var year = Xmas.getYear(); // returns -100
+</pre>
+
+<h3 id="Example:_Setting_and_getting_a_year_between_1900_and_1999" name="Example:_Setting_and_getting_a_year_between_1900_and_1999">Exemplo: Setando e recuperando um ano entre 1900 e 1999</h3>
+
+<p>O segundo statement atribui o valor 95 à variável <code>year</code>, representanto o ano 1995.</p>
+
+<pre class="brush: js">var Xmas.setYear(95);
+var year = Xmas.getYear(); // returns 95
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif;">Especificação</strong></th>
+   <th scope="col">Status</th>
+   <th scope="col"><strong style="background-color: rgba(212, 221, 228, 0.498039); font-family: open sans light,helvetica,arial,sans-serif;">Comentário</strong></th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td><span style="background-color: rgba(212, 221, 228, 0.14902);">Definição inicial. Implementado em JavaScript</span> 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-B.2.4', 'Date.prototype.getYear')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definido em (informativo) compatibilidade annex.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.getyear', 'Date.prototype.getYear')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definido em (normativo) annex para funcionalidades adicionais para futuros browsers web.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setYear()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/index.html b/files/pt-br/web/javascript/reference/global_objects/date/index.html
new file mode 100644
index 0000000000..b83fe9a4fd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/index.html
@@ -0,0 +1,271 @@
+---
+title: Date
+slug: Web/JavaScript/Reference/Global_Objects/Date
+tags:
+  - Date
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/Date
+---
+<div>{{JSRef("Global_Objects", "Date")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>Cria uma instância JavaScript de <strong><code>Date</code></strong> que representa um único momento no tempo. Objetos Date são baseados no valor de tempo que é o número de milisegundos desde 1º de Janeiro de 1970 (UTC).</p>
+
+<h2 id="Syntax" name="Syntax">Construtor</h2>
+
+<pre class="brush: js">new Date();
+new Date(<em>valor</em>);
+new Date(<em>dataString</em>);
+new Date(<em>ano</em>, <em>mês</em>, <em>dia</em>, <em>hora</em>, <em>minuto</em>, <em>segundo</em>, <em>milissegundo</em>);</pre>
+
+<p>{{ note('Note que objetos JavaScript <code>Date</code> só podem ser instanciados chamando JavaScript <code>Date</code> como um construtor: chamá-lo como uma função regular (ou seja, sem o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>) irá retornar uma string ao invés de um objeto <code>Date</code>; ao contrário de outros tipos de objetos JavaScript, objetos JavaScript <code>Date</code> não têm sintaxe literal.') }}</p>
+
+<h3 id="Parameters" name="Parameters">Parâmetros para o constructor Date</h3>
+
+<p>Nota: Quando Date for chamado como um construtor com mais de um argumento, se os valores forem maiores do que seu limite lógico (e.g. se 13 for fornecido como um valor para mês ou 70 for o valor para minuto), o valor adjacente será ajustado. E.g. new Date(2013, 13, 1) é equivalente a new Date(2014, 1, 1), ambos criam uma data para 2014-02-01 (note que o mês começa em 0). Similarmente para outros valores: new Date(2013, 2, 1, 0, 70) é equivalente a new Date(2013, 2, 1, 1, 10), pois ambos criam uma data para 2013-03-01T01:10:00.</p>
+
+<dl>
+ <dt><em><code>value</code></em></dt>
+ <dd>Um valor inteiro representando o número de milisegundos desde 1 de Janeiro de 1970 00:00:00 UTC (Era Unix ou Marco Zero).</dd>
+</dl>
+
+<dl>
+ <dt><em><code>dataString</code></em></dt>
+ <dd>Um valor do tipo String que representa uma data. A string deverá estar uma formato reconhecido pelo método {{jsxref("Date.parse()")}} (<a class="external" href="http://tools.ietf.org/html/rfc2822#page-14" title="http://tools.ietf.org/html/rfc2822#page-14">IETF-compliant RFC 2822 timestamps</a> e também uma <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-15.9.1.15">versão da ISO8601</a>).</dd>
+</dl>
+
+<dl>
+ <dt><em><code>year</code></em></dt>
+ <dd>Um valor inteiro que representa o ano. Valores de 0 a 99 correspondem aos anos de 1900 a 1999. Veja o <a href="#Two digit years">exemplo abaixo</a>.</dd>
+</dl>
+
+<dl>
+ <dt><em><code>month</code></em></dt>
+ <dd>Um valor inteiro que representa o mês, começando com 0 para Janeiro até 11 para Dezembro.</dd>
+</dl>
+
+<dl>
+ <dt><em><code>day</code></em></dt>
+ <dd>Um valor inteiro que representa o dia do mês.</dd>
+</dl>
+
+<dl>
+ <dt><em><code>hour</code></em></dt>
+ <dd>Um valor inteiro que representa a hora do dia.</dd>
+</dl>
+
+<dl>
+ <dt><em><code>minute</code></em></dt>
+ <dd>Um valor inteiro que representa o segmento de um minuto de tempo.</dd>
+</dl>
+
+<dl>
+ <dt><em><code>second</code></em></dt>
+ <dd>Um valor inteiro que representa o segmento de segundo do tempo.</dd>
+</dl>
+
+<dl>
+ <dt><em><code>millisecond</code></em></dt>
+ <dd>Um valor inteiro que representa o segmento de milisegundo do tempo.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<ul>
+ <li>Se nenhum argumento for fornecido, o construtor criará um objeto JavaScript Date com a data e hora corrente de acordo com as configurações do sistema.</li>
+ <li>Se ao menos 2 argumentos forem fornecidos, os argumentos ausentes serão configurados como 1 (se o dia estiver ausente) ou 0 para todos os outros.</li>
+ <li>A data do JavaScript é baseada no valor de tempo em milisegundos desde a meia noite de 01 de Janeiro de 1970, UTC. Um dia corresponde a 86.400,000 milisegundos. O intervalo do objeto Date no JavaScript é de -100.000,000 dias a 100.000,000 dias relativo a 01 de Janeiro de 1970, UTC.</li>
+ <li>O objeto Date no JavaScript tem um comportamento uniforme nas plataformas. O valor do tempo pode ser transmitido entre sistemas para representar o mesmo instante no tempo e se for usado para criar um objeto de data local, ele refletirá o tempo local equivalente.</li>
+ <li>O objeto Date JavaScript suporta vários métodos UTC (universal), assim como métodos de tempo locais. UTC, também conhecido como Tempo Médio de Greenwich (Greenwich Mean Time, GMT), refere-se ao tempo como definido pelo Padrão de Tempo Mundial (World Time Standard). O tempo local é o tempo conhecido pelo computador onde o JavaScript é executado.</li>
+ <li>Invocar o objeto Date no JavaScript como uma função (i.e., sem o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>) retornatá uma string representando a data e hora corrente.</li>
+</ul>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("Date.prototype")}}</dt>
+ <dd>Permite adicionar propriedades a um objeto javaScript Date.</dd>
+ <dt>Date.length</dt>
+ <dd>O valor de <code>Date.length</code> é 7. Esse é o número de argumentos manipulados pelo construtor.</dd>
+</dl>
+
+<p>{{ jsOverrides("Function", "properties", "prototype") }}</p>
+
+<h2 id="Methods" name="Methods">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Date.now()")}}</dt>
+ <dd>Retorna o valor numérico correspondente ao tempo corrente - o número de milisegundos passados desde 1 de Janeiro de 1970 00:00:00 UTC.</dd>
+ <dt>{{jsxref("Date.parse()")}}</dt>
+ <dd>Analisa uma string que representa uma data e retorna o número de milisegundos desde 1 de Janeiro, 1970, 00:00:00, hora local.</dd>
+ <dt>{{jsxref("Date.UTC()")}}</dt>
+ <dd>Aceita os mesmos parâmetros como a forma mais longa do construtor (i.e. 2 até 7) e retorna o número de milisegundos desde 1 de Janeiro, 1970, 00:00:00 UTC. </dd>
+</dl>
+
+<p>{{ jsOverrides("Function", "Methods", "now", "parse", "UTC") }}</p>
+
+<h2 id="Date_instances" name="Date_instances">Instâncias JavaScript de <code>Date</code> </h2>
+
+<p>Todas as instâncias <code>Date</code> são herdadas de {{jsxref("Date.prototype")}}. O objeto protótipo do construtor <code>Date</code> pode ser modificado para afetar todas as instâncias de <code>Date</code>.</p>
+
+<h3 id="Métodos">Métodos</h3>
+
+<p>{{ page("/en-US/docs/JavaScript/Reference/Global_Objects/Date/prototype", "Methods") }}</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Several_ways_to_assign_dates" name="Example:_Several_ways_to_assign_dates">Várias formas de se criar um objeto Date</h3>
+
+<p>Os seguintes exemplos mostram várias formas de se criar datas em JavaScript: </p>
+
+<div class="note">
+<p><strong>Nota:</strong> a conversão de <em>strings</em> com o construtor de <code>Date</code> (<code>Date.parse</code> é equivalente ao contrutor) é fortemente desencorajada devido às inconsistências e diferenças dos navegadores.</p>
+</div>
+
+<pre class="brush: js">var today = new Date();
+var birthday = new Date("December 17, 1995 03:24:00");
+var birthday = new Date("1995-12-17T03:24:00");
+var birthday = new Date(1995,11,17);
+var birthday = new Date(1995,11,17,3,24,0);
+</pre>
+
+<h3 id="Anos_com_dois_dígitos_mapeados_para_1900_-_1999"><a name="Two digit years">Anos com dois dígitos mapeados para 1900 - 1999</a></h3>
+
+<p>Para criar e obter datas entre os anos 0 e 99 os métodos {{jsxref("Date.prototype.setFullYear()")}} e {{jsxref("Date.prototype.getFullYear()")}} devem ser usados.</p>
+
+<pre class="brush: js">var data = new Date(98, 1); //<span class="objectBox objectBox-string"> Dom Fev 01 1998 00:00:00 GMT+0000 (GMT)</span>
+
+// Métodos em desuso, 98 mapeia para 1998 aqui também
+data.setYear(98);           // Dom Fev 01 1998 00:00:00 GMT+0000 (GMT)
+
+data.setFullYear(98);       // Sab Fev 01 0098 00:00:00 GMT+0000 (BST)</pre>
+
+<h3 id="Example:_Calculating_elapsed_time" name="Example:_Calculating_elapsed_time">Calculando o tempo decorrido</h3>
+
+<p>Os seguintes exemplos mostram como determinar o tempo decorrido entre duas datas no JavaScript em milissegundos.</p>
+
+<p>Devido aos tamanhos diferentes dos dias (devido à mudança do horário de verão), meses e dias, expressar o tempo decorrido em unidades maiores que horas, minutos e segundos requer analisar os problemas e deve ser cuidadosamente investigado antes de se tentar utilizar.</p>
+
+<pre class="brush: js">// usando objetos Date
+var inicio = Date.now();
+
+// o evento para o tempo vai aqui:
+facaAlgoPorUmLongoTempo();
+var fim = Date.now();
+var decorrido = fim - inicio; // tempo decorrido em milisegundos
+</pre>
+
+<pre class="brush: js">// utilizando métodos embutidos
+var inicio = new Date();
+
+// o evento para o tempo vai aqui:
+facaAlgoPorUmLongoTempo();
+var fim = new Date();
+var decorrido = fim.getTime() - inicio.getTime(); // tempo decorrido em milisegundos
+</pre>
+
+<pre class="brush: js">// para testar uma função e obter o seu retorno
+function imprimirTempoDecorrido(fTeste) {
+	var nHoraInicial = Date.now(),
+        vRetorno = fTeste(),
+        nHoraFinal = Date.now();
+
+	alert("Tempo decorrido: " + String(nHoraFinal - nHoraInicial) + " milisegundos");
+	return vRetorno;
+}
+
+retornoDaSuaFuncao = imprimirTempoDecorrido(suaFuncao);
+</pre>
+
+<div class="note">
+<p>Nota: Em navegadores que suportam a API de Desempenho Web ({{domxref("window.performance", "Web Performance API", "", 1)}}) com o recurso de tempo de alta resolução, {{domxref("Performance.now()")}} pode fornecer medidas de tempo decorrido mais confiáveis e precisas do que {{jsxref("Date.now()")}}.</p>
+</div>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date-objects', 'Date')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date-objects', 'Date')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9', 'Date')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown()}} [1]</td>
+   <td>{{CompatVersionUnknown()}} [1]</td>
+   <td>{{CompatVersionUnknown()}} [2]</td>
+   <td>{{CompatVersionUnknown()}} [1]</td>
+   <td>{{CompatVersionUnknown()}} [1]</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td><span style="font-size: 12px; line-height: 18px;">Suporte Básico</span></td>
+   <td>{{CompatVersionUnknown()}}</td>
+   <td>{{CompatVersionUnknown()}}</td>
+   <td>{{CompatVersionUnknown()}}</td>
+   <td>{{CompatVersionUnknown()}}</td>
+   <td>{{CompatVersionUnknown()}}</td>
+   <td>{{CompatVersionUnknown()}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Alguns navegadores pode ter problemas quando verificam datas: <a href="http://dygraphs.com/date-formats.html">3/14/2012 blog from danvk Comparing FF/IE/Chrome on Parsing Date Strings</a></p>
+
+<p>[2] <a href="https://msdn.microsoft.com/en-us//library/ie/ff743760(v=vs.94).aspx">ISO8601 Date Format não é suportado</a> o Internet Explorer 8 e outras versões podem ter <a href="http://dygraphs.com/date-formats.html">problemas quando convertem datas</a></p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/now/index.html b/files/pt-br/web/javascript/reference/global_objects/date/now/index.html
new file mode 100644
index 0000000000..2eef32c0b7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/now/index.html
@@ -0,0 +1,126 @@
+---
+title: Date.now()
+slug: Web/JavaScript/Reference/Global_Objects/Date/now
+tags:
+  - JavaScript
+  - Reference
+  - Referencia
+  - data
+  - metodo
+  - polyfill
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/now
+---
+<div>{{JSRef("Global_Objects", "Date")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método<strong><code> Date.now()</code></strong> retorna o número de milisegundos decorridos desde 1 de janeiro de 1970 00:00:00 UTC.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox">var timeInMs = Date.now();
+</pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<p>Nenhum.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O método <strong><code>now()</code></strong> retorna os milisegundos decorridos desde 1 de janeiro de 1970 00:00:00 UTC até agora como um  {{jsxref("Global_Objects/Number", "Number")}}.</p>
+
+<p>Por que <strong><code>now</code> </strong>é um método estático de <strong><code>Date</code></strong>, você sempre o usará como <strong><code>Date.now()</code></strong>.</p>
+
+<h2 id="Compatibility" name="Compatibility">Polyfill</h2>
+
+<p>Este método foi padronizado no ECMA-262 5<sup>th</sup> edition. Em ambientes que não estão atualizados para suportar este método você pode suprir esta carência utilizando o seguinte:</p>
+
+<pre class="brush: js">if (!Date.now) {
+  Date.now = function now() {
+    return new Date().getTime();
+  };
+}
+</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('ES5.1', '#sec-15.9.4.4', 'Date.now')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.5</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.now', 'Date.now')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<p>Baseado em <a href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>5</td>
+   <td>3</td>
+   <td>9</td>
+   <td>10.50</td>
+   <td>4</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{domxref("window.performance.now")}} - fornece timestamps com sub-millisegundo precisão para uso em medir o desempenho da página</li>
+ <li>{{domxref("console.time")}} / {{domxref("console.timeEnd")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/parse/index.html b/files/pt-br/web/javascript/reference/global_objects/date/parse/index.html
new file mode 100644
index 0000000000..ccba92e923
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/parse/index.html
@@ -0,0 +1,214 @@
+---
+title: Date.parse()
+slug: Web/JavaScript/Reference/Global_Objects/Date/parse
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/parse
+---
+<div> {{JSRef("Global_Objects", "Date")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong><code>Date.parse()</code></strong> analisa uma representação de data em <em>string</em>, e retorna o número de milisegundos desde 01 de Janeiro de 1970, 00:00:00 UTC ou NaN se a string não for reconhecida ou, em alguns casos, contiver valores inválidos de data (ex. 2015-02-31).</p>
+
+<p>O uso de <code>Date.parse</code> não é recomendado, uma vez que até ES5 a análise de strings era inteiramente dependente de implementação. Ainda existem muitas diferenças de como diferentes plataformas analisam strings de data, então strings de data devem ser manualmente analisadas (uma biblioteca pode ajudar caso seja necessário atender a vários formatos)</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<p>Chamada direta:</p>
+
+<pre class="syntaxbox notranslate"><code>Date.parse(<var>dateString</var>)</code></pre>
+
+<p>Chamada implícita:</p>
+
+<pre class="syntaxbox notranslate"><code>new Date(<var>dateString</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>dateString</code></dt>
+ <dd>Uma <em>string</em> de representação de datas no format <a href="http://tools.ietf.org/html/rfc2822#page-14">RFC2822</a> ou ISO 8601 (outros formatos podem ser utilizados, mas os resultados podem não ser os esperados).</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O método <code>parse()</code> analisa uma <em>string</em> de data (como <code>"Dec 25, 1995"</code>) e retorna o número de milisegundos desde 01 de Janeiro de 1970, 00:00:00 UTC. Esta função é útil para definir valores de data baseados em valores de <em>string</em>, por exemplo em conjunto com o método {{jsxref("Date.prototype.setTime()", "setTime()")}} e o objeto {{jsxref("Global_Objects/Date", "Date")}}.</p>
+
+<p>Dada uma string representando um tempo, <code>parse()</code> retorna o valor temporal. É aceito o RFC2822 / IETF sintaxe de data (<a href="http://tools.ietf.org/html/rfc2822#page-14">RFC2822 Section 3.3</a>), ex.: <code>"Mon, 25 Dec 1995 13:30:00 GMT"</code>. A função entende as abreviações dos fusos horários continentais dos EUA, mas para uso geral, use um deslocamento de fuso horário, por exemplo, <code>"Seg, 25 Dez 1995 13:30:00 +0430"</code> (4 horas, 30 minutos à leste do Meridiano de Greenwich). Se o fuso horário não é especificado e a string está em um formato ISO reconhecido pela ES5, então é adotado o formato UTC (Tempo Universal Coordenado). GMT e UTC são considerados equivalentes. O fuso horário do seu horário local é usado para interpreatar argumentos na <a href="http://tools.ietf.org/html/rfc2822#page-14">RFC2822 Formato 3.3</a> (ou qualquer formato não reconhecido como ISO 8601 na ES5) que não contenha informação de fuso horário.
+
+</p><h3 id="Suporte_ao_formato_ECMAScript_5_ISO-8601">Suporte ao formato ECMAScript 5 ISO-8601</h3>
+
+<p><em>Astring </em>Data e hora pode ser no formato <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a>. Por exemplo, <code>"2011-10-10"</code> (apenas data) ou <code>"2011-10-10T14:48:00"</code> (data e hora) podem ser passados ou convertidos. O fuso horario UTC é usado para interpretar  argumentos no formato <a href="http://www.w3.org/TR/NOTE-datetime">ISO 8601</a> que não contenham informação de fuso horário (note que <a href="http://people.mozilla.org/~jorendorff/es6-draft.html#sec-date-time-string-format">ECMAScript ed 6 draft</a> especifica que  a <em>string </em>do tipo data e hora sem um fuso horário são tratados como data local, não UTC).</p>
+
+<p>While time zone specifiers are used during date string parsing to interpret the argument, the value returned is always the number of milliseconds between January 1, 1970 00:00:00 UTC and the point in time represented by the argument.</p>
+
+<p>Because <code>parse()</code> is a static method of {{jsxref("Global_Objects/Date", "Date")}}, it is called as <code>Date.parse()</code> rather than as a method of a {{jsxref("Global_Objects/Date", "Date")}} instance.</p>
+
+<h3 id="Differences_in_assumed_time-zone" name="Differences_in_assumed_time-zone">Differences in assumed time zone</h3>
+
+<p>Given a date string of <code>"March 7, 2014"</code>, <code>parse()</code> assumes a local time zone, but given an ISO format such as <code>"2014-03-07"</code> it will assume a time zone of UTC. Therefore {{jsxref("Global_Objects/Date", "Date")}} objects produced using those strings will represent different moments in time unless the system is set with a local time zone of UTC. This means that two date strings that appear equivalent may result in two different values depending on the format of the string that is being converted (this behavior is changed in ECMAScript ed 6 so that both will be treated as local).</p>
+
+<h3 id="Fall-back_to_implementation-specific_date_formats">Fall-back to implementation-specific date formats</h3>
+
+<p>The ECMAScript specification states: If the String does not conform to the standard format the function may fall back to any implementation–specific heuristics or implementation–specific parsing algorithm. Unrecognizable strings or dates containing illegal element values in ISO formatted strings shall cause <code>Date.parse()</code> to return {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
+
+<p>However, invalid values in date strings not recognized as ISO format as defined by ES5 may or may not result in {{jsxref("Global_Objects/NaN", "NaN")}}, depending on the browser and values provided, e.g.:</p>
+
+<pre class="brush: js notranslate">// Non-ISO string with invalid date values
+new Date('23/25/2014');
+</pre>
+
+<p>will be treated as a local date of 25 November, 2015 in Firefox 30 and an invalid date in Safari 7. However, if the string is recognized as an ISO format string and it contains invalid values, it will return {{jsxref("Global_Objects/NaN", "NaN")}} in all browsers compliant with ES5:</p>
+
+<pre class="brush: js notranslate">// ISO string with invalid values
+new Date('2014-25-23').toISOString();
+// returns "RangeError: invalid date" in all es5 compliant browsers
+</pre>
+
+<p>SpiderMonkey's implementation-specific heuristic can be found in <a href="http://mxr.mozilla.org/mozilla-central/source/js/src/jsdate.cpp?rev=64553c483cd1#889"><code>jsdate.cpp</code></a>. The string <code>"10 06 2014"</code> is an example of a non–conforming ISO format and thus falls back to a custom routine. See also this <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=1023155#c6">rough outline</a> on how the parsing works.</p>
+
+<pre class="brush: js notranslate">new Date('10 06 2014');
+</pre>
+
+<p>will be treated as a local date of 6 October, 2014 and not 10 June, 2014. Other examples:</p>
+
+<pre class="brush: js notranslate">new Date('foo-bar 2014').toString();
+// returns: "Invalid Date"
+
+Date.parse('foo-bar 2014');
+// returns: NaN
+</pre>
+
+<h2 id="Examples" name="Examples">Examples</h2>
+
+<h3 id="Example_Using_parse" name="Example:_Using_parse">Example: Using <code>Date.parse()</code></h3>
+
+<p>If <code>IPOdate</code> is an existing {{jsxref("Global_Objects/Date", "Date")}} object, it can be set to August 9, 1995 (local time) as follows:</p>
+
+<pre class="brush: js notranslate">IPOdate.setTime(Date.parse('Aug 9, 1995'));</pre>
+
+<p>Some other examples of parsing non–standard date strings:</p>
+
+<pre class="brush: js notranslate">Date.parse('Aug 9, 1995');</pre>
+
+<p>Returns <code>807937200000</code> in time zone GMT-0300, and other values in other time zones, since the string does not specify a time zone and is not ISO format, therefore the time zone defaults to local.</p>
+
+<pre class="brush: js notranslate">Date.parse('Wed, 09 Aug 1995 00:00:00 GMT');</pre>
+
+<p>Returns <code>807926400000</code> no matter the local time zone as GMT (UTC) is provided.</p>
+
+<pre class="brush: js notranslate">Date.parse('Wed, 09 Aug 1995 00:00:00');</pre>
+
+<p>Returns <code>807937200000</code> in time zone GMT-0300, and other values in other time zones, since there is no time zone specifier in the argument and it is not ISO format, so is treated as local.</p>
+
+<pre class="brush: js notranslate">Date.parse('Thu, 01 Jan 1970 00:00:00 GMT');</pre>
+
+<p>Returns <code>0</code> no matter the local time zone as a time zone GMT (UTC) is provided.</p>
+
+<pre class="brush: js notranslate">Date.parse('Thu, 01 Jan 1970 00:00:00');</pre>
+
+<p>Returns <code>14400000</code> in time zone GMT-0400, and other values in other time zones, since no time zone is provided and the string is not in ISO format, therfore the local time zone is used.</p>
+
+<pre class="brush: js notranslate">Date.parse('Thu, 01 Jan 1970 00:00:00 GMT-0400');</pre>
+
+<p>Returns <code>14400000</code> no matter the local time zone as a time zone GMT (UTC) is provided.</p>
+
+<h2 id="Specifications">Specifications</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. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.4.2', 'Date.parse')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>ISO 8601 format added.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.parse', 'Date.parse')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>ISO 8601 format</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckodesktop("2.0")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td>ISO 8601 format</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Date.UTC()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setdate/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setdate/index.html
new file mode 100644
index 0000000000..92748130fc
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setdate/index.html
@@ -0,0 +1,80 @@
+---
+title: Date.prototype.setDate()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setDate
+tags:
+  - Date
+  - JavaScript
+  - Métodos
+  - Prototype
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setDate
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setDate()</code></strong> configura o dia do objeto {{jsxref("Date")}} relativamente ao início do mês configurado previamente.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setdate.html")}}</div>
+
+<p class="hidden">A fonte desse exemplo interativo fica guardada em um repositóiro no GitHub. Se você quiser contribuir para o projeto de exemplos interativos, por favor, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a>  e nos envie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setDate(<var>dayValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>dayValue</code></dt>
+ <dd>Um número inteiro que representa o dia do mês.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milisegundos entre 1o de janeiro de 1970 00:00:00 UTC e a data indicada (o objeto {{jsxref("Date")}} é mudado no lugar).</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se o <code>dayValue</code> estiver fora da extensão de valores de data para o mês, <code>setDate()</code> vai atualizar o objeto {{jsxref("Date")}} consequentemente.</p>
+
+<p>Por exemplo, se 0 for fornecido para <code>dayValue</code>, a data será configurada para o último dia do mês anterior.</p>
+
+<p>Se um número negativo for fornecido para <code>dayValue</code>, a data será configurada contando-se regressivamente desde o último dia do mês anterior. -1 resultará na data sendo configurada para um dia antes do último dia o mês anterior.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setDate">Usando <code>setDate()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date(1962, 6, 7); // 1962-07-07 (7th of July 1962)
+theBigDay.setDate(24);  // 1962-07-24 (24th of July 1962)
+theBigDay.setDate(32);  // 1962-08-01 (1st of August 1962)
+theBigDay.setDate(22);  // 1962-08-22 (22th of August 1962)
+theBigDay.setDate(0);   // 1962-07-31 (31th of July 1962)
+theBigDay.setDate(98);  // 1962-10-06 (6th of October 1962)
+theBigDay.setDate(-50); // 1962-08-11 (11th of August 1962)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setdate', 'Date.prototype.setDate')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browsers">Compatibilidade de Browsers</h2>
+
+<p class="hidden">A tabela de compatibilidade nessa página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setDate")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getDate()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCDate()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setfullyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setfullyear/index.html
new file mode 100644
index 0000000000..4f38399a21
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setfullyear/index.html
@@ -0,0 +1,80 @@
+---
+title: Date.prototype.setFullYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setFullYear
+tags:
+  - Date
+  - JavaScript
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setFullYear
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setFullYear()</code></strong> atribui o ano completo para a data especificada de acordo com o horário universal (UTC). Retorna uma nova data e hora.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setfullyear.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dateValue</var>]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>yearValue</code></dt>
+ <dd>Um inteiro especificando o valor número de um ano, por exemplo, 1995.</dd>
+ <dt><code>monthValue</code></dt>
+ <dd>Opcional. Um inteiro entre 0 e 11 representando os meses Janeiro até Dezembro.</dd>
+ <dt><code>dateValue</code></dt>
+ <dd>Opcional. Um inteiro entre 1 e 31 representando o dia do mês. Se você especificar o parâmetro <code>dateValue</code>, você deve também especificar <code>monthValue</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O número de milisegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você não especificar os parâmetros <code>monthValue</code> e <code>dateValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getMonth()", "getMonth()")}} e {{jsxref("Date.prototype.getDate()", "getDate()")}} são usados.</p>
+
+<p>Se um parâmetro que você especificou está fora do alcance esperado, <code>setFullYear()</code> tenta atualizar os outros parâmetros e a informação de data no objeto {{jsxref("Date")}} adequadamente. Por exemplo, se você especificar 15 para o <code>monthValue</code>, o ano será incrementado em 1 (<code>yearValue + 1</code>), e 3 é usado para o mês.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setFullYear">Usando <code>setFullYear()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setFullYear(1997);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setfullyear', 'Date.prototype.setFullYear')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setFullYear")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setYear()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/sethours/index.html b/files/pt-br/web/javascript/reference/global_objects/date/sethours/index.html
new file mode 100644
index 0000000000..77b161e0ce
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/sethours/index.html
@@ -0,0 +1,85 @@
+---
+title: Date.prototype.setHours()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setHours
+tags:
+  - Date
+  - JavaScript
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setHours
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setHours()</code></strong> atribui as horas para uma data especificada de acordo com a hora local e retorna o número de milissegundos desde do dia 1 de Janeiro de 1970 00:00:00 UTC até o tempo representado pela instância {{jsxref("Date")}} atualizada.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-sethours.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre>
+
+<h3 id="Versões_anteriores_ao_JavaScript_1.3">Versões anteriores ao JavaScript 1.3</h3>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setHours(<var>hoursValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>hoursValue</code></dt>
+ <dd>Idealmente, um número inteiro entre 0 e 23, representando a hora. Se um valor maior que 23 for fornecido, a data e hora será incrementada pelas horas extras.</dd>
+ <dt><code>minutesValue</code></dt>
+ <dd>Opcional. Idealmente, um número inteiro entre 0 e 59, representando os minutos. Se um valor maior que 59 for fornecido, a data e hora será incrementada em minutos extras.</dd>
+ <dt><code>secondsValue</code></dt>
+ <dd>Opcional. Idealmente, um número inteiro entre 0 e 59, representando os segundos. Se um valor maior que 59 for fornecido, a data e hora será incrementada em segundos extras. Se você especificar o parâmetro <code>secondsValue</code>, também deverá especificar parâmetro <code>minutesValue</code>.</dd>
+ <dt><code>msValue</code></dt>
+ <dd>Opcional. Idealmente, um número entre 0 e 999, representando os milissegundos. Se um valor maior que 999 for fornecido, a data e hora será incrementada em milissegundos extras. Se você especificar o parâmetro <code>msValue</code>, você também deve especificar <code>minutesValue</code> e <code>secondsValue</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você não especifica os parâmetros <code>minutesValue</code>, <code>secondsValue</code>, e <code>msValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getMinutes()", "getMinutes()")}}, {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}}, e {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}} são usados.</p>
+
+<p>Se um parâmetro que você especificar estiver fora do intervalo esperado, <code>setHours()</code> tenta atualizar as informações de data no objeto {{jsxref("Date")}}. Por exemplo, se você usa 100 para <code>secondsValue</code>, os minutos serão incrementados em 1 (<code>minutesValue + 1</code>), e 40 serão usados para os segundos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setHours">Usando <code>setHours()</code></h3>
+
+<pre class="brush:js notranslate">var theBigDay = new Date();
+theBigDay.setHours(7);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.sethours', 'Date.prototype.setHours')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setHours")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getHours()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setmilliseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setmilliseconds/index.html
new file mode 100644
index 0000000000..f632e02bf9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setmilliseconds/index.html
@@ -0,0 +1,74 @@
+---
+title: Date.prototype.setMilliseconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMilliseconds
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setMilliseconds()</code></strong> atribui os milissegundos para a data específica de acordo com a hora local.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setmilliseconds.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMilliseconds(<var>millisecondsValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>millisecondsValue</code></dt>
+ <dd>Um número entre 0 e 999, representando os milissegundos.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você especifica um número fora do alcance esperado, a informação de data no objeto {{jsxref("Date")}} é atualizado de acordo. Por exemplo, se você especifica 1005, o número de segundos é incrementado em 1, e 5 é utilizado para os milissegundos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setMilliseconds">Usando <code>setMilliseconds()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setMilliseconds(100);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setmilliseconds', 'Date.prototype.setMilliseconds')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setMilliseconds")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMilliseconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMilliseconds()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setminutes/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setminutes/index.html
new file mode 100644
index 0000000000..ece5608638
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setminutes/index.html
@@ -0,0 +1,84 @@
+---
+title: Date.prototype.setMinutes()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setMinutes
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMinutes
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setMinutes()</code></strong> atribui os minutos para uma data específica de acordo com o horário local.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setminutes.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre>
+
+<h3 id="Versões_anteriores_ao_JavaScript_1.3">Versões anteriores ao JavaScript 1.3</h3>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMinutes(<var>minutesValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>minutesValue</code></dt>
+ <dd>Um inteiro entre 0 e 59, representando os mintuos.</dd>
+ <dt><code>secondsValue</code></dt>
+ <dd>Opcional. Um inteiro entre 0 e 59, representando os segundos. Se você especificar o parâmetro <code>secondsValue</code>, você também deve especificar <code>minutesValue</code>.</dd>
+ <dt><code>msValue</code></dt>
+ <dd>Opcional. Um número entre 0 e 999, representando os milissegundos. Se você especificar o parâmetro <code>msValue</code>, você deve também especificar <code>minutesValue</code> e <code>secondsValue</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você não especifica os parâmetros <code>secondsValue</code> e <code>msValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getSeconds()", "getSeconds()")}} e {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}} são usados.</p>
+
+<p>Se um parâmetro que você especificou estiver fora do alcance esperado, <code>setMinutes()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usa 100 para <code>secondsValue</code>, os minutos serão incrementados em 1 (<code>minutesValue + 1</code>), e 40 serão usados para segundos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setMinutes">Usando <code>setMinutes()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setMinutes(45);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setminutes', 'Date.prototype.setMinutes')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setMinutes")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMinutes()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMinutes()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setmonth/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setmonth/index.html
new file mode 100644
index 0000000000..e9ac42302a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setmonth/index.html
@@ -0,0 +1,87 @@
+---
+title: Date.prototype.setMonth()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setMonth
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setMonth
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setMonth()</code></strong> atribui o mês para uma data específica de acordo com o ano corrente.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setmonth.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre>
+
+<h3 id="Versões_anteriores_ao_JavaScript_1.3">Versões anteriores ao JavaScript 1.3</h3>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setMonth(<var>monthValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>monthValue</code></dt>
+ <dd>Um inteiro baseado em zero representando o mês do ano a partir do começo do ano. Então, 0 representa Janeiro, 11 representa Dezembro, -1 representa Dezembro do ano passado, e 12 representa Janeiro do ano seguinte.</dd>
+ <dt><code>dayValue</code></dt>
+ <dd>Opcional. Um inteiro de 1 a 31, representando o dia do mês.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre dia 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você não especifica o parâmetro <code>dayValue</code>, o valor retornado do método {{jsxref("Date.prototype.getDate()", "getDate()")}} é utilizado.</p>
+
+<p>Se um parâmetro que você especificou estiver fora do alcance esperado, <code>setMonth()</code> tenta atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usa 15 para <code>monthValue</code>, o ano será incrementado em 1, e 3 será usado para o mês.</p>
+
+<p>O dia corrente do mês terá um impacto no comportamento deste método. Conceitualmente ele irá adicionar o número de dias dado pelo dia corrente do mês ao primeiro dia do novo mês especificado como parâmetro, retornando uma nova data. Por exemplo, se o valor corrente é 31 de agosto de 2016, chamando <code>setMonth()</code> com um valor de 1 irá retornar 2 de Março de 2016. Isso acontece porque Fevereiro de 2016 tem 29 dias.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setMonth">Usando <code>setMonth()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setMonth(6);
+
+//Cuidado com transições de final de mês
+var endOfMonth = new Date(2016, 7, 31);
+endOfMonth.setMonth(1);
+console.log(endOfMonth); //Wed Mar 02 2016 00:00:00
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setmonth', 'Date.prototype.setMonth')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setMonth")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getMonth()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCMonth()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setseconds/index.html
new file mode 100644
index 0000000000..b474ec29a2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setseconds/index.html
@@ -0,0 +1,82 @@
+---
+title: Date.prototype.setSeconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setSeconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setSeconds
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setSeconds()</code></strong> atribui os segundos na data especificada de acordo com o tempo local.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setseconds.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre>
+
+<h3 id="Versões_anteriores_ao_JavaScript_1.3">Versões anteriores ao JavaScript 1.3</h3>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setSeconds(<var>secondsValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>secondsValue</code></dt>
+ <dd>Um inteiro entre 0 e 59, representando os segundos.</dd>
+ <dt><code>msValue</code></dt>
+ <dd>Opcional. Um número entre 0 e 999, representando os milissegundos.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você não especifica o parâmetro <code>msValue</code>, o valor retornado do método {{jsxref("Date.prototype.getMilliseconds()", "getMilliseconds()")}} é utilizado.</p>
+
+<p>Se um parâmetro que você especificou está fora do alcance esperado, <code>setSeconds()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 100 para <code>secondsValue</code>, os minutos guardados no objeto {{jsxref("Date")}} serão incrementados em 1, e 40 serão usados para os segundos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setSeconds">Usando <code>setSeconds()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setSeconds(30);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setseconds', 'Date.prototype.setSeconds')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setSeconds")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getSeconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCSeconds()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/settime/index.html b/files/pt-br/web/javascript/reference/global_objects/date/settime/index.html
new file mode 100644
index 0000000000..cc4f4472ba
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/settime/index.html
@@ -0,0 +1,95 @@
+---
+title: Date.prototype.setTime()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setTime
+tags:
+  - Date
+  - JavaScript
+  - Prototype
+  - Referencia
+  - Tempo
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setTime
+---
+<div>{{JSRef}}</div>
+
+<div>O método <strong><code>setTime() </code></strong>atribui ao objecto {{jsxref("Date")}} a hora representada pelo número de milisegundos desde 1 de janeiro de 1970 as 00:00:00 UTC.</div>
+
+<div> </div>
+
+<div>{{EmbedInteractiveExample("pages/js/date-settime.html")}}</div>
+
+<p class="hidden">A fonte para este exemplo interativo está armazenado em um repositório do GitHub. Se você gostaria de contribuir para o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p>
+
+<h2 id="Sintáxe">Sintáxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.setTime(<var>timeValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>timeValue</code></dt>
+ <dd>Um inteiro representando o número de milisegundos desde 1 de janeiro 1970, 00:00:00 UTC.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O número de milisegundos entre 1 de janeiro de 1970 00:00:00 UTC e a data atualizada (efetivamente, o valor do argumento).</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Use o método <code>setTime()</code> para ajudar a atribuir data e hora para outro objeto {{jsxref("Date")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setTime()">Usando <code>setTime()</code></h3>
+
+<pre class="brush: js">var theBigDay = new Date('July 1, 1999');
+var sameAsBigDay = new Date();
+sameAsBigDay.setTime(theBigDay.getTime());
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.27', 'Date.prototype.setTime')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.settime', 'Date.prototype.setTime')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_Browsers">Compatibilidade nos Browsers</h2>
+
+<p class="hidden">A tabela de compatibilidade nesta página é gerada a patir de dados estruturados. Caso queira contribuir com os dados, por favor confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setTime")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getTime()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCHours()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcdate/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcdate/index.html
new file mode 100644
index 0000000000..4190b96120
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcdate/index.html
@@ -0,0 +1,74 @@
+---
+title: Date.prototype.setUTCDate()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCDate
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setUTCDate()</code></strong> atribui o dia do mês para uma data especifica de acordo com o horário universal.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setutcdate.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCDate(<var>dayValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>dayValue</code></dt>
+ <dd>Um inteiro entre 1 e 31, representando o dia do mês.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se um parâmetro que você especificou está fora do alcance esperado, <code>setUTCDate()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 40 para <code>dayValue</code>, e o mês guardado no objeto {{jsxref("Date")}} é Junho, o dia será trocado para 10 e o mês será incrementado para Julho.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setUTCDate">Usando <code>setUTCDate()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setUTCDate(20);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcdate', 'Date.prototype.setUTCDate')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setUTCDate")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCDate()")}}</li>
+ <li>{{jsxref("Date.prototype.setDate()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcfullyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcfullyear/index.html
new file mode 100644
index 0000000000..657b65d9aa
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcfullyear/index.html
@@ -0,0 +1,80 @@
+---
+title: Date.prototype.setUTCFullYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCFullYear
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setUTCFullYear()</code></strong> atribui o ano completo na data especificada de acordo com o horário universal.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setutcfullyear.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCFullYear(<var>yearValue</var>[, <var>monthValue</var>[, <var>dayValue</var>]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>yearValue</code></dt>
+ <dd>Um inteiro especificando o valor numérico do ano, por exemplo, 1995.</dd>
+ <dt><code>monthValue</code></dt>
+ <dd>Opcional. Um inteiro entre 0 e 11 representando os meses Janeiro até Dezembro.</dd>
+ <dt><code>dayValue</code></dt>
+ <dd>Opcional. Um inteiro entre 1 e 31 representando o dia do mês. Se você especificar o parâmetro <code>dayValue</code>, vocẽ deve especificar <code>monthValue</code> também.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você não especificar os parâmetros <code>monthValue</code> e <code>dayValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getUTCMonth()", "getUTCMonth()")}} e {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}} serão utilizados.</p>
+
+<p>Se um parâmetro que você especificou está fora do alcance esperado, <code>setUTCFullYear()</code> tentará atualizar os outros parâmetros e a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você especificar 15 para o <code>monthValue</code>, o ano será incrementado em 1 (<code>yearValue + 1</code>), e 3 será usado para o mês.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setUTCFullYear">Usando <code>setUTCFullYear()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setUTCFullYear(1997);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcfullyear', 'Date.prototype.setUTCFullYear')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setUTCFullYear")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutchours/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutchours/index.html
new file mode 100644
index 0000000000..5d1304b708
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setutchours/index.html
@@ -0,0 +1,82 @@
+---
+title: Date.prototype.setUTCHours()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCHours
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setUTCHours()</code></strong> atribui a hora para a data especificada de acordo com o horário universal, e retorna o número de milissegundos desde 1 de Janeiro de 1970 00:00:00 UTC até o horário representado pela instância {{jsxref("Date")}} atualizada.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setutchours.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCHours(<var>hoursValue</var>[, <var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>hoursValue</code></dt>
+ <dd>Um inteiro entre 0 e 23, representando a hora.</dd>
+ <dt><code>minutesValue</code></dt>
+ <dd>Opcional. Um inteiro entre 0 e 59, representando os minutos.</dd>
+ <dt><code>secondsValue</code></dt>
+ <dd>Opcional. Um inteiro entre 0 e 59, representando os segundos. Se você especificar o parâmetro <code>secondsValue</code>, você também deve especificar <code>minutesValue</code>.</dd>
+ <dt><code>msValue</code></dt>
+ <dd>Opcional. Um número entre 0 e 999, representando os milissegundos. Se você especificar o parâmetro <code>msValue</code>, você também deve especificar <code>minutesValue</code> e <code>secondsValue</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você não especificar os parâmetros <code>minutesValue</code>, <code>secondsValue</code>, e <code>msValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getUTCMinutes()", "getUTCMinutes()")}}, {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}}, e {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}} serão utilizados.</p>
+
+<p>Se o parâmetro que você especificou estiver fora do alcance esperado, <code>setUTCHours()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usa 100 para <code>secondsValue</code>, os minutos serão incrementados em 1 (<code>minutesValue + 1</code>), e 40 será usado para os segundos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setUTCHours">Usando <code>setUTCHours()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setUTCHours(8);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutchours', 'Date.prototype.setUTCHours')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setUTCHours")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCHours()")}}</li>
+ <li>{{jsxref("Date.prototype.setHours()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html
new file mode 100644
index 0000000000..3d52820944
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcmilliseconds/index.html
@@ -0,0 +1,74 @@
+---
+title: Date.prototype.setUTCMilliseconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMilliseconds
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setUTCMilliseconds()</code></strong> atribui os milissegundos para a data especificada de acordo com o horário universal.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setutcmilliseconds.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCMilliseconds(<var>millisecondsValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>millisecondsValue</code></dt>
+ <dd>Um número entre 0 e 999, representando os milissegundos.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se o parâmetro que você especificou estiver fora do alcance esperado, <code>setUTCMilliseconds()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 1100 para <code>millisecondsValue</code>, os segundos guardados no objeto {{jsxref("Date")}} serão incrementados em 1, e 100 serão usados para os milissegundos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setUTCMilliseconds">Usando <code>setUTCMilliseconds()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setUTCMilliseconds(500);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcmilliseconds', 'Date.prototype.setUTCMilliseconds')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setUTCMilliseconds")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMilliseconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setMilliseconds()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcminutes/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcminutes/index.html
new file mode 100644
index 0000000000..d0dd60beda
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcminutes/index.html
@@ -0,0 +1,80 @@
+---
+title: Date.prototype.setUTCMinutes()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMinutes
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setUTCMinutes()</code></strong> atribui os minutos para uma data específica de acordo com o horário universal.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setutcminutes.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCMinutes(<var>minutesValue</var>[, <var>secondsValue</var>[, <var>msValue</var>]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>minutesValue</code></dt>
+ <dd>Um inteiro entre 0 e 59, representando os minutos.</dd>
+ <dt><code>secondsValue</code></dt>
+ <dd>Opcional. Um inteiro entre 0 e 59, reprensentando os segundos. Se vocẽ especificar o parâmetro <code>secondsValue</code>, você também deve especificar <code>minutesValue</code>.</dd>
+ <dt><code>msValue</code></dt>
+ <dd>Opcional. Um número entre 0 e 999, representando os milissegundos. Se você especificar o parâmetro <code>msValue</code>, você também deve especificar <code>minutesValue</code> e <code>secondsValue</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se vocẽ não especificar os parâmetros <code>secondsValue</code> e <code>msValue</code>, os valores retornados dos métodos {{jsxref("Date.prototype.getUTCSeconds()", "getUTCSeconds()")}} e {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}} são utilizados.</p>
+
+<p>Se o parâmetro que você especificou estiver fora do alcance esperado, <code>setUTCMinutes()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 100 para <code>secondsValue</code>, os minutos serão incrementados em 1 (<code>minutesValue + 1</code>), e 40 será usado para os segundos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setUTCMinutes">Usando <code>setUTCMinutes()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setUTCMinutes(43);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcminutes', 'Date.prototype.setUTCMinutes')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setUTCMinutes")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMinutes()")}}</li>
+ <li>{{jsxref("Date.prototype.setMinutes()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcmonth/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcmonth/index.html
new file mode 100644
index 0000000000..3dd9758665
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcmonth/index.html
@@ -0,0 +1,78 @@
+---
+title: Date.prototype.setUTCMonth()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCMonth
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setUTCMonth()</code></strong> atribui o mês para a data especificada de acordo com o horário universal.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setutcmonth.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCMonth(<var>monthValue</var>[, <var>dayValue</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>monthValue</code></dt>
+ <dd>Um inteiro entre 0 e 11, representando os meses de Janeiro até Dezembro.</dd>
+ <dt><code>dayValue</code></dt>
+ <dd>Opcional. Um inteiro de 1 a 31, representando o dia do mês.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você não especificar o parâmetro <code>dayValue</code>, o valor returnado do método {{jsxref("Date.prototype.getUTCDate()", "getUTCDate()")}} é utilizado.</p>
+
+<p>Se um parâmetro que você especificou está fora do alcance especificado, <code>setUTCMonth()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 15 para <code>monthValue</code>, o ano irá incrementar em 1, e 3 será usado para o mês.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setUTCMonth">Usando <code>setUTCMonth()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setUTCMonth(11);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcmonth', 'Date.prototype.setUTCMonth')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setUTCMonth")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCMonth()")}}</li>
+ <li>{{jsxref("Date.prototype.setMonth()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setutcseconds/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setutcseconds/index.html
new file mode 100644
index 0000000000..2876f9a69b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setutcseconds/index.html
@@ -0,0 +1,78 @@
+---
+title: Date.prototype.setUTCSeconds()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setUTCSeconds
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>setUTCSeconds()</code></strong> atribui os segundos para a data especificada de acordo com o horário universal.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-setutcseconds.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setUTCSeconds(<var>secondsValue</var>[, <var>msValue</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>secondsValue</code></dt>
+ <dd>Um inteiro entre 0 e 59, representando os segundos.</dd>
+ <dt><code>msValue</code></dt>
+ <dd>Opcional. Um número entre 0 e 999, representando os milissegundos.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você não especifica o parâmetro <code>msValue</code>, o valor retornado pelo método {{jsxref("Date.prototype.getUTCMilliseconds()", "getUTCMilliseconds()")}} é utilizado.</p>
+
+<p>Se o parâmetro que você especificou está fora do alcance esperado, <code>setUTCSeconds()</code> tentará atualizar a informação da data no objeto {{jsxref("Date")}}. Por exemplo, se você usar 100 para <code>secondsValue</code>, os minutos guardados no objeto {{jsxref("Date")}} irá ser incrementado em 1, e 40 será usado para os segundos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setUTCSeconds">Usando <code>setUTCSeconds()</code></h3>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+theBigDay.setUTCSeconds(20);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setutcseconds', 'Date.prototype.setUTCSeconds')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setUTCSeconds")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getUTCSeconds()")}}</li>
+ <li>{{jsxref("Date.prototype.setSeconds()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/setyear/index.html b/files/pt-br/web/javascript/reference/global_objects/date/setyear/index.html
new file mode 100644
index 0000000000..afd2bfa615
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/setyear/index.html
@@ -0,0 +1,79 @@
+---
+title: Date.prototype.setYear()
+slug: Web/JavaScript/Reference/Global_Objects/Date/setYear
+tags:
+  - Date
+  - Deprecated
+  - Depreciado
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/setYear
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <strong><code>setYear()</code></strong> atribui o ano para a data especificada de acordo com o horário local. Devido <code>setYear()</code> não colocar o anos cheios ("problema do ano 2000"), ele não é mais utilizado e foi substituído pelo método {{jsxref("Date.prototype.setFullYear()", "setFullYear()")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.setYear(<var>yearValue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>yearValue</code></dt>
+ <dd>Um inteiro.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data atualizada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se <code>yearValue</code> é um número entre 0 e 99 (inclusivo), então o ano para <code>dateObj</code> é atribuido para <code>1900 + yearValue</code>. Caso contrário, o ano para <code>dateObj</code> é atribuido para <code>yearValue</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_setYear">Usando <code>setYear()</code></h3>
+
+<p>As duas primeiras linhas atribuem o ano para 1996. O terceiro atribui o ano para 2000.</p>
+
+<pre class="brush: js notranslate">var theBigDay = new Date();
+
+theBigDay.setYear(96);
+theBigDay.setYear(1996);
+theBigDay.setYear(2000);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.setyear', 'Date.prototype.setYear')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.setYear")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.getFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.getUTCFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setFullYear()")}}</li>
+ <li>{{jsxref("Date.prototype.setUTCFullYear()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/todatestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/todatestring/index.html
new file mode 100644
index 0000000000..ac4e3cbc11
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/todatestring/index.html
@@ -0,0 +1,127 @@
+---
+title: Date.prototype.toDateString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toDateString
+tags:
+  - Date
+  - JavaScript
+  - Prototipo
+  - Prototype
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toDateString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toDateString()</code></strong> retorna a porção da data de um objeto {{jsxref("Date")}} em um formato legível para humanos em inglês dos Estados Unidos.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>objetoDate</var>.toDateString()</code></pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Exemplares de {{jsxref("Date")}} referem-se a um ponto específico no tempo. Chamar {{jsxref("Date.prototype.toString()", "toString()")}} retorna a data num formato legível para humanos em inglês dos Estados Unidos. No <a href="/en-US/docs/SpiderMonkey">SpiderMonkey</a>, isso consiste na porção da data (dia, mês e ano) seguida pela porção da hora (horas, minutos, segundos e fuso horário). Ás vezes, deseja-se obter uma string apenas da porção da data; Isso pode ser conseguido com o método <code>toDateString()</code>.</p>
+
+<p><code>O método toDateString()</code> é especialmente útil porque motores que implementam o padrão <a href="/en-US/docs/ECMAScript">ECMA-262</a> podem divergir na string retornada pelo {{jsxref("Date.prototype.toString()", "toString()")}} de objetos {{jsxref("Date")}} , pois o formato é dependente da implentação e abordagens simples que repartem a string podem não produzir resultados consistentes nos vários motores.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Um_uso_básico_de_toDateString()">Um uso básico de <code>toDateString()</code></h3>
+
+<pre class="brush: js">var d = new Date(1993, 6, 28, 14, 39, 7);
+
+console.log(d.toString());     // exibe Wed Jul 28 1993 14:39:07 GMT-0600 (PDT) no log
+console.log(d.toDateString()); // exibe Wed Jul 28 1993 no log
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.3', 'Date.prototype.toDateString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.todatestring', 'Date.prototype.toDateString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Móvel (Gecko)</th>
+   <th>IE Móvel</th>
+   <th>Opera Móvel</th>
+   <th>Safari Móvel</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/togmtstring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/togmtstring/index.html
new file mode 100644
index 0000000000..1df4801950
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/togmtstring/index.html
@@ -0,0 +1,70 @@
+---
+title: Date.prototype.toGMTString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toGMTString
+tags:
+  - Date
+  - Deprecated
+  - Depreciado
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toGMTString
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <strong><code>toGMTString()</code></strong> converte a data para uma cadeia de caracteres (<em>string)</em>, usando as convenções de Internet para o Horário de Greenwich (GMT). O formato exato do valor retornado por <code>toGMTString()</code> varia de acordo com plataforma e navegador, em geral ele deve representar uma <em>string</em> legível para um ser humano.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> <code>toGMTString()</code> está depreciado e não deve ser mais usado. Ele se mantém implementado somente para retrocompatibilidade; por favor use {{jsxref("Date.prototype.toUTCString()", "toUTCString()")}}.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.toGMTString()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string</em> representando a data seguindo a convenção de Internet para o Horário de Greenwich (GMT).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Simple_example">Simple example</h3>
+
+<p>Neste exemplo, o método <code>toGMTString()</code> converte a data para GMT (UTC) usando o deslocamento de fuso horário do sistema operacional e retorna uma <em>string </em>que é similar a seguinta forma. O formato exato depende da plataforma.</p>
+
+<pre class="brush: js notranslate">var today = new Date();
+var str = today.toGMTString();  // depreciado! use toUTCString()
+
+console.log(str);               // Mon, 18 Dec 1995 17:28:35 GMT
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.togmtstring', 'Date.prototype.toGMTString')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toGMTString")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toUTCString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/toisostring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/toisostring/index.html
new file mode 100644
index 0000000000..14fb14cfc1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/toisostring/index.html
@@ -0,0 +1,97 @@
+---
+title: Date.prototype.toISOString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toISOString
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+  - polyfill
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toISOString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toISOString()</code></strong> retorna uma cadeia de caracteres (<em>string</em>) simplificada no formato ISO extendido (<a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a>), que é sempre 24 ou 27 caracteres de tamanho (<code><var>YYYY</var>-<var>MM</var>-<var>DD</var>T<var>HH</var>:<var>mm</var>:<var>ss.sss</var>Z</code> ou <code><var>±</var><var>YYYYYY</var>-<var>MM</var>-<var>DD</var>T<var>HH</var>:<var>mm</var>:<var>ss.sss</var>Z</code>, respectivamente). O fuso horário é sempre o deslocamente zero UTC, como denotado pelo sufixo "<code>Z</code>".</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-toisostring.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.toISOString()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string</em> representando a data no formato <a href="http://en.wikipedia.org/wiki/ISO_8601">ISO 8601</a> de acordo com o horário universal.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Este método foi padronizado na quinta edição da ECMA-262. Motores que não foram atualizados para suportar este método podem funcionar com uma gambiarra na ausência deste método da seguinte forma:</p>
+
+<pre class="brush: js notranslate">if (!Date.prototype.toISOString) {
+  (function() {
+
+    function pad(number) {
+      if (number &lt; 10) {
+        return '0' + number;
+      }
+      return number;
+    }
+
+    Date.prototype.toISOString = function() {
+      return this.getUTCFullYear() +
+        '-' + pad(this.getUTCMonth() + 1) +
+        '-' + pad(this.getUTCDate()) +
+        'T' + pad(this.getUTCHours()) +
+        ':' + pad(this.getUTCMinutes()) +
+        ':' + pad(this.getUTCSeconds()) +
+        '.' + (this.getUTCMilliseconds() / 1000).toFixed(3).slice(2, 5) +
+        'Z';
+    };
+
+  })();
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toISOString">Usando <code>toISOString()</code></h3>
+
+<pre class="brush: js notranslate">let today = new Date('05 October 2011 14:48 UTC')
+
+console.log(today.toISOString())  // Returna 2011-10-05T14:48:00.000Z
+</pre>
+
+<p>O exemplo acima usa uma conversão de uma <em>string</em> não-padrão que pode não ser convertida corretamente em navegadores que não sejam da Mozilla..</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.toisostring', 'Date.prototype.toISOString')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toISOString")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toUTCString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tojson/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tojson/index.html
new file mode 100644
index 0000000000..d35a98c99a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/tojson/index.html
@@ -0,0 +1,75 @@
+---
+title: Date.prototype.toJSON()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toJSON
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toJSON
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toJSON()</code></strong> retorna uma representação representation do objeto  {{jsxref("Date")}} como string.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-tojson.html")}}</div>
+
+<p class="hidden">O código fonte para este exemplo interativo está armazenado em um repositório no GitHub. Caso queira contribuir com os exemplos interativos do projeto, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie-nos um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toJSON()</code></pre>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Uma representação da data como string.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Instâncias de {{jsxref("Date")}} referem-se a um específico ponto no tempo. Invocar <code>toJSON()</code> retorna uma string (usando {{jsxref("Date.prototype.toISOString()", "toISOString()")}}) representando o valor do objeto {{jsxref("Date")}}. Por padrão este método é destinado a serializar objetos {{jsxref("Date")}} em serializações {{Glossary("JSON")}}.</p>
+
+<h2 id="Examplos">Examplos</h2>
+
+<h3 id="Usando_toJSON()">Usando <code>toJSON()</code></h3>
+
+<pre class="brush:js">var jsonDate = (new Date()).toJSON();
+var backToDate = new Date(jsonDate);
+
+console.log(jsonDate); //2015-10-26T07:46:36.611Z
+</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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.44', 'Date.prototype.toJSON')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.tojson', 'Date.prototype.toJSON')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navagadores">Compatibilidade com navagadores</h2>
+
+<p class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Caso queira contribuir com dados confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toJSON")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toUTCString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tolocaledatestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tolocaledatestring/index.html
new file mode 100644
index 0000000000..410807cb37
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/tolocaledatestring/index.html
@@ -0,0 +1,239 @@
+---
+title: Date.prototype.toLocaleDateString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleDateString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toLocaleDateString()</code></strong> retorna uma string com a representação de parte da data baseando-se no idioma. Os novos argumentos <code>locales</code> e <code>options</code> deixam as aplicações especificarem o idioma cujas convenções de formatação devem ser usadas e permitem customizar o comportamento da função. Em implementações antigas, nas quais ignoram os argumentos <code>locales</code> e <code>options</code>,  o locale usado e a forma da string retornada são inteiramente dependente da implementação nativa.</p>
+
+<h2 id="Sintáxe">Sintáxe</h2>
+
+<pre class="syntaxbox"><var>dateObj</var>.toLocaleDateString([<var>locales</var> [, <var>options</var>]])</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<p>Verifique a seção {{anch("Compatibilidade entre navegadores")}} para ver quais navegadores dão suporte aos argumentos <code>locales</code> e <code>options</code>, e o <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Example:  Verificação para suporte dos argumentos<code> locales</code> e <code>options</code></a> para detectar a funcionalidade.</p>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div>
+
+<div>O valor padrão para cada propriedade do componente date-time é {{jsxref("undefined")}}, mas se as propriedades <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code> são todas {{jsxref("undefined")}}, então <code>year</code>, <code>month </code>and <code>day </code>são assumidos como "<code>numeric</code>".</div>
+
+<h3 id="sect1"></h3>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Uma representação em string de parte da data dada a instância {{jsxref("Global_Objects/Date", "Date")}} de acordo com as convenções específicas do idioma. </p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toLocaleDateString">Usando <code>toLocaleDateString()</code></h3>
+
+<p>Em uso básico sem especificação de locale, uma string formatada no padrão do locale e com as opções padrões é retornada.</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
+
+// toLocaleDateString() sem argumentos depende da implementação,
+// o locale padrão, e o time zone padrão
+console.log(date.toLocaleDateString());
+// → "12/11/2012" se rondando em locale en-US com time zone de America/Los_Angeles
+</pre>
+
+<h3 id="Checagem_para_o_suporte_dos_argumentos_locales_e_options">Checagem para o suporte dos argumentos <code>locales</code> e <code>options</code></h3>
+
+<p>Os argumentos <code>locales</code> e <code>options</code> não são suportados em todos os browser ainda.  Para verificar se uma uma implementação já suporta eles, você pode usar o requisito de que tags de idioma ilegal são rejeitadas com uma exceção {{jsxref("RangeError")}}:</p>
+
+<pre class="brush: js">function toLocaleDateStringSupportsLocales() {
+  try {
+    new Date().toLocaleDateString('i');
+  } catch (e) {
+    return e.name === 'RangeError';
+  }
+  return false;
+}
+</pre>
+
+<h3 id="Usando_locales">Usando <code>locales</code></h3>
+
+<p>Esse exemplo mostra algumas das variações em formatos de data localizados. A fim de obter oformato do idioma usado na interface de usuário da usa aplicação, certifique-se de especificar esse idioma (e possivelmente algumas outros idiomas de reserva) usando o argumento <code>locales</code>: </p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// os formatos abaixo assumem o time zone local do locale;
+// America/Los_Angeles for the US
+
+// Inglês americano usa a ordem mês-dia-ano
+console.log(date.toLocaleDateString('en-US'));
+// → "12/19/2012"
+
+// Inglês Britânico usa a ordem dia-mês-ano
+console.log(date.toLocaleDateString('en-GB'));
+// → "20/12/2012"
+
+// Coreano usa a ordem ano-mês-dia
+console.log(date.toLocaleDateString('ko-KR'));
+// → "2012. 12. 20."
+
+// Árabe na maioria dos países de língua árabe usa dígitos árabes reais
+console.log(date.toLocaleDateString('ar-EG'));
+// → "<span dir="rtl">٢٠‏/١٢‏/٢٠١٢</span>"
+
+// para Japonês, aplicações podem querer usar o calendário japonês,
+// onde 2012 foi o ano 24 da era Heisei
+console.log(date.toLocaleDateString('ja-JP-u-ca-japanese'));
+// → "24/12/20"
+
+// quando um idioma que pode não ser suportado é requerido, tal como
+// Balinês, inclua um idioma de reserva, nesse caso Indonésio
+console.log(date.toLocaleDateString(['ban', 'id']));
+// → "20/12/2012"
+</pre>
+
+<h3 id="Usando_options">Usando <code>options</code></h3>
+
+<p>O resultados gerados por <code>toLocaleDateString()</code> podem ser customizado usando o argumento <code>options</code>:</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// requer um dia da semana jutamente com uma data longa
+var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
+console.log(date.toLocaleDateString('de-DE', options));
+// → "Donnerstag, 20. Dezember 2012"
+
+// uma aplicação pode querer usar UTC e fazê-lo visível
+options.timeZone = 'UTC';
+options.timeZoneName = 'short';
+console.log(date.toLocaleDateString('en-US', options));
+// → "Thursday, December 20, 2012, GMT"
+</pre>
+
+<h2 id="Performance">Performance</h2>
+
+<p>Ao formatar um grande número de datas, é melhor criar um objeto {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} e usar a função fornecido porsua propriedade {{jsxref("DateTimeFormat.prototype.format", "format")}}.</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>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', 'sec-15.9.5.6', 'Date.prototype.toLocaleDateString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocaledatestring', 'Date.prototype.toLocaleDateString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 1.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td>Define os argumentos <code>locales</code> e <code>options</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-13.3.2', 'Date.prototype.toLocaleDateString')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleDateString', 'Date.prototype.toLocaleDateString')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_o_navegador">Compatibilidade com o navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td><code>locales</code> and <code>options</code> arguments</td>
+   <td>{{CompatChrome("24")}} [1]</td>
+   <td>{{CompatGeckoDesktop("29")}}</td>
+   <td>{{CompatIE("11")}}</td>
+   <td>{{CompatOpera("15")}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td><code>locales</code> and <code>options</code> arguments</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("26")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Chrome 24 also added support for passing timeZones other than UTC.</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tolocalestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tolocalestring/index.html
new file mode 100644
index 0000000000..06d9b1f30c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/tolocalestring/index.html
@@ -0,0 +1,202 @@
+---
+title: Date.prototype.toLocaleString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
+tags:
+  - Internacionalização
+  - JavaScript
+  - Prototype
+  - Referencia
+  - data
+  - i18n
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toLocaleString()</code></strong> retorna uma <em>string</em><strong> </strong>com uma representação sensível ao idioma da data presente na mesma. Os novos argumentos <code>locales</code> e <code>options</code> permitem que as aplicações especifiquem o idioma cujas convenções de formatação devem ser utilizadas e personalizar o comportamento do método. Em implementações antigas, que ignoram os argumentos <code>locales</code> and <code>options</code>, o local utilizado e o formato da <em>string</em> retornada são completamente dependentes da implementação.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-tolocalestring.html")}}</div>
+
+<p class="hidden">O código-fonte deste exemplo interativo está armazenado em um repositório do GitHub. Se você quiser contribuir com o projeto de exemplos interativos, por favor clone o repositório <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie-nos <em>pull requests</em>.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>dateObj</var>.toLocaleString([<var>locales</var>[, <var>options</var>]])</pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<p>Check the <a href="#Browser_Compatibility">Browser compatibility</a> section to see which browsers support the <code>locales</code> and <code>options</code> arguments, and the <a href="#Example:_Checking_for_support_for_locales_and_options_arguments">Example: Checking for support for <code>locales</code> and <code>options</code> arguments</a> for feature detection.</p>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div>
+
+<p>The default value for each date-time component property is {{jsxref("undefined")}}, but if the <code>weekday</code>, <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, <code>second</code> properties are all {{jsxref("undefined")}}, then <code>year</code>, <code>month</code>, <code>day</code>, <code>hour</code>, <code>minute</code>, and <code>second</code> are assumed to be <code>"numeric"</code>.</p>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>A string representing the given date according to language-specific conventions.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_toLocaleString()">Using <code>toLocaleString()</code></h3>
+
+<p>In basic use without specifying a locale, a formatted string in the default locale and with default options is returned.</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
+
+// toLocaleString() without arguments depends on the implementation,
+// the default locale, and the default time zone
+console.log(date.toLocaleString());
+// → "12/11/2012, 7:00:00 PM" if run in en-US locale with time zone America/Los_Angeles
+</pre>
+
+<h3 id="Checking_for_support_for_locales_and_options_arguments">Checking for support for <code>locales</code> and <code>options</code> arguments</h3>
+
+<p>The <code>locales</code> and <code>options</code> arguments are not supported in all browsers yet. To check whether an implementation supports them already, you can use the requirement that illegal language tags are rejected with a {{jsxref("RangeError")}} exception:</p>
+
+<pre class="brush: js">function toLocaleStringSupportsLocales() {
+  try {
+    new Date().toLocaleString('i');
+  } catch (e) {
+    return e instanceof RangeError;
+  }
+  return false;
+}
+</pre>
+
+<h3 id="Using_locales">Using <code>locales</code></h3>
+
+<p>This example shows some of the variations in localized date and time formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the <code>locales</code> argument:</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// formats below assume the local time zone of the locale;
+// America/Los_Angeles for the US
+
+// US English uses month-day-year order and 12-hour time with AM/PM
+console.log(date.toLocaleString('en-US'));
+// → "12/19/2012, 7:00:00 PM"
+
+// British English uses day-month-year order and 24-hour time without AM/PM
+console.log(date.toLocaleString('en-GB'));
+// → "20/12/2012 03:00:00"
+
+// Korean uses year-month-day order and 12-hour time with AM/PM
+console.log(date.toLocaleString('ko-KR'));
+// → "2012. 12. 20. 오후 12:00:00"
+
+// Arabic in most Arabic speaking countries uses real Arabic digits
+console.log(date.toLocaleString('ar-EG'));
+// → "<span dir="rtl">٢٠‏/١٢‏/٢٠١٢ ٥:٠٠:٠٠ ص</span>"
+
+// for Japanese, applications may want to use the Japanese calendar,
+// where 2012 was the year 24 of the Heisei era
+console.log(date.toLocaleString('ja-JP-u-ca-japanese'));
+// → "24/12/20 12:00:00"
+
+// when requesting a language that may not be supported, such as
+// Balinese, include a fallback language, in this case Indonesian
+console.log(date.toLocaleString(['ban', 'id']));
+// → "20/12/2012 11.00.00"
+</pre>
+
+<h3 id="Using_options">Using <code>options</code></h3>
+
+<p>The results provided by <code>toLocaleString()</code> can be customized using the <code>options</code> argument:</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// request a weekday along with a long date
+var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
+console.log(date.toLocaleString('de-DE', options));
+// → "Donnerstag, 20. Dezember 2012"
+
+// an application may want to use UTC and make that visible
+options.timeZone = 'UTC';
+options.timeZoneName = 'short';
+console.log(date.toLocaleString('en-US', options));
+// → "Thursday, December 20, 2012, GMT"
+
+// sometimes even the US needs 24-hour time
+console.log(date.toLocaleString('en-US', { hour12: false }));
+// → "12/19/2012, 19:00:00"
+</pre>
+
+<h3 id="Avoid_comparing_formatted_date_values_to_static_values">Avoid comparing formatted date values to static values</h3>
+
+<p>Most of the time, the formatting returned by <code>toLocaleString()</code> is consistent. However, this might change in the future and isn't guaranteed for all languages — output variations are by design and allowed by the specification. Most notably, the IE and Edge browsers insert bidirectional control characters around dates, so the output text will flow properly when concatenated with other text.</p>
+
+<p>For this reason you cannot expect to be able to compare the results of <code>toLocaleString()</code> to a static value:</p>
+
+<pre class="brush: js; example-bad">"1.1.2019, 01:00:00" === new Date("2019-01-01T00:00:00.000000Z").toLocaleString();
+// true in Firefox and others
+// false in IE and Edge</pre>
+
+<div class="blockIndicator note">
+<p><strong>Note</strong>: See also this <a href="https://stackoverflow.com/questions/25574963/ies-tolocalestring-has-strange-characters-in-results">StackOverflow thread</a> for more details and examples.</p>
+</div>
+
+<h2 id="Performance">Performance</h2>
+
+<p>When formatting large numbers of dates, it is better to create an {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} object and use the function provided by its {{jsxref("DateTimeFormat.prototype.format", "format")}} property.</p>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.5', 'Date.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 1.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td>Defines <code>locales</code> and <code>options</code> arguments.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-13.3.1', 'Date.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleString', 'Date.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toLocaleString")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tolocaletimestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tolocaletimestring/index.html
new file mode 100644
index 0000000000..9b149abb00
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/tolocaletimestring/index.html
@@ -0,0 +1,180 @@
+---
+title: Date.prototype.toLocaleTimeString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString
+tags:
+  - Internacionalização
+  - Prototype
+  - data
+  - data formatada
+  - fuso horário
+  - metodo
+  - time zone
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toLocaleTimeString
+---
+<div>{{JSRef}}</div>
+
+<div>O método <strong><code>toLocaleTimeString()</code></strong> retorna uma string com uma representação sensível ao idioma de uma porção de tempo desta data. Os novos argumentos <code>locales</code> e <code>options</code> possibilitam aplicações especificarem que formato de linguagem deve ser usado, podendo customizar o comportamento da função. Em implementações antigas, que ignoram os argumentos <code>locales</code> e <code>options</code>, o local utilizado e o formato retornado da string são implementações completamente dependentes.</div>
+
+<div> </div>
+
+<div>{{EmbedInteractiveExample("pages/js/date-tolocaletimestring.html")}}</div>
+
+<p class="hidden">A fonte deste exemplo interativo é armazenado em um repositório do GitHub. Se você deseja contribuir em exemplos interativos, por favor, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>dateObj</var>.toLocaleTimeString([<var>locales</var>[, <var>options</var>]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p>Confira a seção <a href="#Browser_Compatibility">Browser compatibility</a> para ver o suporte em browsers dos argumentos <code>locales</code> e <code>options</code>, e  <a href="#Checking_for_support_for_locales_and_options_arguments">Checking for support for <code>locales</code> and <code>options</code> arguments</a> para ver suas features.</p>
+
+<div>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat', 'Parameters')}}</div>
+
+<p>O valor default para cada propriedade do componente date-time é {{jsxref("undefined")}}, mas se as propriedades <code>hour</code>, <code>minute</code>, <code>second</code> são todas {{jsxref("undefined")}}, então <code>hour</code>, <code>minute</code>, e <code>second</code> espera-se que seja <code>"numeric"</code>.</p>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string representando uma porção de tempo de uma instância {{jsxref("Global_Objects/Date", "Date")}}, fornecida de acordo com as convenções específicas do idioma.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toLocaleTimeString()">Usando <code>toLocaleTimeString()</code></h3>
+
+<p>Em um uso simples, sem especificar uma localidade, é retornado uma string formatada de uma localidade default e com opções default.</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 12, 3, 0, 0));
+
+// toLocaleTimeString() sem argumentos, depende da implementação,
+// da localidade padrão, e do fuso horário padrão
+console.log(date.toLocaleTimeString());
+// → "7:00:00 PM" se rodar em en-US com o fuso horário de America/Los_Angeles
+</pre>
+
+<h3 id="Verificando_o_suporte_para_os_argumentos_locales_e_options">Verificando o suporte para os argumentos <code>locales</code> e <code>options</code></h3>
+
+<p>Os argumentos <code>locales</code> e <code>options</code> não são suportados em todos os browsers ainda. Para conferir se uma implementação já os suporta, você pode usar a exigência que tags ilegais de liguagem são rejeitadas com uma exceção {{jsxref("RangeError")}}:</p>
+
+<pre class="brush: js">function toLocaleTimeStringSupportsLocales() {
+  try {
+    new Date().toLocaleTimeString('i');
+  } catch (e) {
+    return e​.name === 'RangeError';
+  }
+  return false;
+}
+</pre>
+
+<h3 id="Usando_locales">Usando <code>locales</code></h3>
+
+<p>Este exemplo mostra algumas das variações em um formato de tempo localizado. Para obter o formato do idioma usado na interface do usuário da sua aplicação, tenha certeza de especificar esse idioma (e possivelmente alguns idiomas de retorno) usando o argumento <code>locales</code>:</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// Os formatos abaixo assumem o fuso horário local da região;
+// America/Los_Angeles for the US
+
+// US English usa o formato 12 horas com AM/PM
+console.log(date.toLocaleTimeString('en-US'));
+// → "7:00:00 PM"
+
+// British English usa o formato 24 horas sem AM/PM
+console.log(date.toLocaleTimeString('en-GB'));
+// → "03:00:00"
+
+// Korean usa o formato 12 horas com AM/PM
+console.log(date.toLocaleTimeString('ko-KR'));
+// → "오후 12:00:00"
+
+// Arabic na maiorias dos países que falam árabe usa-se os dígitos arábicos reais
+console.log(date.toLocaleTimeString('ar-EG'));
+// → "<span dir="rtl">٧:٠٠:٠٠ م</span>"
+
+// quando solicitar um idioma que talvez não seja suportado, como o
+// Balinese, inclua um idioma de fallback, nesse caso Indonesian
+console.log(date.toLocaleTimeString(['ban', 'id']));
+// → "11.00.00"
+</pre>
+
+<h3 id="Usando_options">Usando <code>options</code></h3>
+
+<p>Os resultados fornecidos por <code>toLocaleTimeString()</code> podem ser customizados usando o argumento <code>options</code>:</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// uma aplicação pode querer usar UTC e tornar isso visível
+var options = { timeZone: 'UTC', timeZoneName: 'short' };
+console.log(date.toLocaleTimeString('en-US', options));
+// → "3:00:00 AM GMT"
+
+// ás vezes, até em US precise usar o formato 24 horas
+console.log(date.toLocaleTimeString('en-US', { hour12: false }));
+// → "19:00:00"
+</pre>
+
+<h2 id="Performance">Performance</h2>
+
+<p>Quando se formata um grande número de datas, é aconselhável criar um objeto {{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}} e usar a função fornecida pela propriedade dele: {{jsxref("DateTimeFormat.prototype.format", "format")}}.</p>
+
+<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('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial, Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.5.7', 'Date.prototype.toLocaleTimeString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.tolocalestring', 'Date.prototype.toLocaleTimeString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 1.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td>Define os argumentos <code>locales</code> e <code>options</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-13.3.3', 'Date.prototype.toLocaleTimeString')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sec-Date.prototype.toLocaleTimeString', 'Date.prototype.toLocaleTimeString')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_Browsers">Compatibilidade em Browsers</h2>
+
+<p class="hidden">A tabela de compatibilidade nessa página é gerada por dados estruturados. Se você deseja contribuir com esses dados, por favor confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toLocaleTimeString")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tosource/index.html
new file mode 100644
index 0000000000..62c829b7ec
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/tosource/index.html
@@ -0,0 +1,53 @@
+---
+title: Date.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toSource
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toSource
+---
+<div>{{JSRef}} {{obsolete_header}}</div>
+
+<p>O método <strong><code>toSource()</code></strong> retorna uma cadeia de caracteres (<em>string</em>) representando o código fonte do objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>dateObj</var>.toSource()
+Date.toSource()</pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string </em>representando o código fonte do objeto {{jsxref("Global_Objects/Date", "Date")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Função_nativa">Função nativa</h3>
+
+<p>Para o objeto {{jsxref("Date")}} embutido, <code>toSource()</code> returna a seguinte <em>string</em> indicando que o código fonte não está disponível:</p>
+
+<pre class="brush: js notranslate">function Date() {
+    [native code]
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de nenhum padrão.</p>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toSource")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/tostring/index.html
new file mode 100644
index 0000000000..f06c2ab6ca
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/tostring/index.html
@@ -0,0 +1,114 @@
+---
+title: Date.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toString
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toString()</code></strong> retorna uma cadeia de caracteres (<em>string</em>) representando o objeto {{jsxref("Date")}} especificado.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-tostring.html","shorter")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>dateObj</var>.toString()</pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string</em> representando a data.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Instâncias de {{jsxref("Date")}} herdam o método <code>toString()</code> de {{jsxref("Date.prototype")}}, não {{jsxref("Object.prototype")}}. <code>Date.prototype.toString()</code> returna uma <em>string</em> com a representação de Date no formato especificado na ECMA-262 que pode ser resumida como:</p>
+
+<ul>
+ <li>Dia da semana: 3 letras do nome do dia da semana em Inglês, e.g. "Sat"</li>
+ <li>espaço</li>
+ <li>Nome do mês: 3 letras do nome do mês em Inglês, e.g. "Sep"</li>
+ <li>espaço</li>
+ <li>Dia: Dia do mês em 2 dígitos, e.g. "01"</li>
+ <li>espaço</li>
+ <li>Ano: Ano no formato de 4 dígitos, e.g. "2018"</li>
+ <li>espaço</li>
+ <li>Hora: Hora do dia em 2 dígitos, e.g. "14"</li>
+ <li><span><span>dois-pontos</span></span></li>
+ <li>Minuto: Minutos da hora em 2 dígitos, e.g. "53"</li>
+ <li><span><span>dois-pontos</span></span></li>
+ <li>Segundos: Segundos do minuto em 2 dígitos, e.g. "26"</li>
+ <li>espaço</li>
+ <li>A <em>string</em> "GMT"</li>
+ <li>Sinal do deslocamento do fuso horário, pode ser:
+  <ul>
+   <li>"+" para deslocamentos positivos (0 ou maior)</li>
+   <li>"-" para deslocamentos negativos (menores que 0)</li>
+  </ul>
+ </li>
+ <li>Dois dígitos da hora do deslocamento, e.g. "14"</li>
+ <li>Dois dígitos dos minutos do deslocamento, e.g. "00"</li>
+ <li>Opcionalmente, um nome de fuso horário consistindo de:
+  <ul>
+   <li>espaço</li>
+   <li>parênteses esquerdo, i.e. "("</li>
+   <li>Uma representação de <em>string</em> dependente da implementação do fuso horário, que pode ser uma abreviação ou o nome completo (não há um padrão para nomes ou abreviação de fusos horários), e.g. "Line Islands Time" ou "LINT"</li>
+   <li>parênteses direito, i.e. ")"</li>
+  </ul>
+ </li>
+</ul>
+
+<p>E.g. "Sat Sep 01 2018 14:53:26 GMT+1400 (LINT)"</p>
+
+<p>Até o ECMAScript 2018 (edição 9), o formato da <em>string</em> retornada pelo <code>Date.prototype.toString</code> era dependente da implementação. Portanto, não se deve confiar que ela está no formato especificado.</p>
+
+<p>O método <code>toString()</code> é automaticamente chamado quando a data deve ser representada como texto, e.g. <code>console.log(new Date())</code>, ou quando a data é utilizada em uma concatenação de <em>string</em>, como <code>var today = 'Today is ' + new Date()</code>.</p>
+
+<p><code>toString()</code> é um método genérico, ele não requer que seu <code>this</code> seja uma instância de {{jsxref("Date")}}. Entretanto, ele deve ter uma propriedade interna <code>[[TimeValue]]</code> que não pode ser construída usando JavaScript nativo, então ela é efetivamente limitada a ser usada com instâncias {{jsxref("Date")}}. Se chamado em uma instância que não seja Date, um {{jsxref("TypeError")}} é jogado.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toString">Usando <code>toString()</code></h3>
+
+<p>O exemplo asseguir atribui o valor de <code>toString()</code> de um objeto {{jsxref("Date")}} para <code>myVar</code>:</p>
+
+<pre class="brush: js notranslate">var x = new Date();
+var myVar = x.toString(); // atribui uma string em myVar no mesmo formato que este:
+                          // Mon Sep 08 1998 14:36:22 GMT-0700 (PDT)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.tostring', 'Date.prototype.toString')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toString")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+ <li>{{jsxref("Date.prototype.toDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date.prototype.toTimeString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/totimestring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/totimestring/index.html
new file mode 100644
index 0000000000..852bf9ec95
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/totimestring/index.html
@@ -0,0 +1,72 @@
+---
+title: Date.prototype.toTimeString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toTimeString
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toTimeString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toTimeString()</code></strong> retorna uma porção de tempo de um objeto {{jsxref("Date")}} de forma legível para um ser humano em Inglês Americano.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-totimestring.html","shorter")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.toTimeString()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string</em> representando a porção de tempo da data de forma legível para um ser humano em Inglês Americano.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Instâncias de {{jsxref("Date")}} referem-se a um ponto específico no tempo. Chamando {{jsxref("Date.prototype.toString()", "toString()")}} irá retornar uma data formatada de forma legível para um ser humano em Inglês Americano. No <a href="/en-US/docs/SpiderMonkey">SpiderMonkey</a>, isso consiste na porção da data (dia, mês e ano) seguido pela porção de tempo (horas, minutos, segundos e fuso horário). Algumas vezes é desejável obter a <em>string</em> da porção do tempo; tal coisa pode ser atingida utilizando o método <code>toTimeString()</code>.</p>
+
+<p>O <code>toTimeString()</code> método é especialmente útil por que motores parecidos que implementam a <a href="/en-US/docs/ECMAScript">ECMA-262</a> podem ter <em>string</em><em>s </em>diferentes obtidas de {{jsxref("Date.prototype.toString()", "toString()")}} para objetos {{jsxref("Date")}}, como o formato é dependente de implementação;  abordagens de corte simples de <em>string</em><em>s </em>pode não produzir resultados consistentes entre múltiplos motores.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Uso_básico_de_toTimeString">Uso básico de <code>toTimeString()</code></h3>
+
+<pre class="brush: js notranslate">var d = new Date(1993, 6, 28, 14, 39, 7);
+
+console.log(d.toString());     // Wed Jul 28 1993 14:39:07 GMT-0600 (PDT)
+console.log(d.toTimeString()); // 14:39:07 GMT-0600 (PDT)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.totimestring', 'Date.prototype.toTimeString')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toTimeString")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
+ <li>{{jsxref("Date.prototype.toDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/toutcstring/index.html b/files/pt-br/web/javascript/reference/global_objects/date/toutcstring/index.html
new file mode 100644
index 0000000000..470841dc1a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/toutcstring/index.html
@@ -0,0 +1,113 @@
+---
+title: Date.prototype.toUTCString()
+slug: Web/JavaScript/Reference/Global_Objects/Date/toUTCString
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/toUTCString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toUTCString()</code></strong> converte uma data para uma cadeia de caracteres (<em>string</em>), usando o fuso horário UTC.</p>
+
+<p>Baseado na <a href="https://tools.ietf.org/html/rfc7231#section-7.1.1.1">RFC7231</a> e modificado de acordo com a <a href="https://www.ecma-international.org/ecma-262/10.0/index.html#sec-date.prototype.toutcstring">ECMA-262 toUTCString</a>, ele pode ter valores negativos na <a href="https://tc39.es/ecma262/#sec-date.prototype.toutcstring">versão de 2021</a>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-toutcstring.html","shorter")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.toUTCString()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string</em> representando a data usando o fuso horário UTC.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O valor retornado por <code>toUTCString()</code> é uma <em>string</em> no formato <code><var>Www</var>, <var>dd</var> <var>Mmm</var> <var>yyyy</var> <var>hh</var>:<var>mm</var>:<var>ss</var> GMT</code>, onde:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Formato da String</th>
+   <th scope="col">Descrição</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><code><var>Www</var></code></td>
+   <td>Dia da semana, em três letras (e.g. Sun, Mon, ...)</td>
+  </tr>
+  <tr>
+   <td><code><var>dd</var></code></td>
+   <td>Dia do mês, como dois dígitos com zero à esquerda se requisitado</td>
+  </tr>
+  <tr>
+   <td><code><var>Mmm</var></code></td>
+   <td>Mês, em três letras (e.g. Jan, Feb, ...)</td>
+  </tr>
+  <tr>
+   <td><code><var>yyyy</var></code></td>
+   <td>Ano, como 4 ou mais dígitos com zeros à esquerda se requisitado</td>
+  </tr>
+  <tr>
+   <td><code><var>hh</var></code></td>
+   <td>Hora, como dois dígitos com zero à esquerda se requisitado</td>
+  </tr>
+  <tr>
+   <td><code><var>mm</var></code></td>
+   <td>Minutos, como dois dígitos com zero à esquerda se requisitado</td>
+  </tr>
+  <tr>
+   <td><code><var>ss</var></code></td>
+   <td>Segundos, como dois dígitos com zero à esquerda se requisitado</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Antes do ECMAScript 2018, o formato do valor de retorno variava de acordo com a plataforma. O valor de retorno mais comum era um carimbo de data formatada na  RFC-1123, que é uma versão relativamente atualizada dos carimbos de data da RFC-822.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toUTCString">Usando <code>toUTCString()</code></h3>
+
+<pre class="brush: js notranslate">let today = new Date('Wed, 14 Jun 2017 00:00:00 PDT');
+let UTCstring = today.toUTCString(); // Wed, 14 Jun 2017 07:00:00 GMT
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.toutcstring', 'Date.prototype.toUTCString')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.toUTCString")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date.prototype.toDateString()")}}</li>
+ <li>{{jsxref("Date.prototype.toISOString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/utc/index.html b/files/pt-br/web/javascript/reference/global_objects/date/utc/index.html
new file mode 100644
index 0000000000..4684f83afa
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/utc/index.html
@@ -0,0 +1,145 @@
+---
+title: Date.UTC()
+slug: Web/JavaScript/Reference/Global_Objects/Date/UTC
+tags:
+  - JavaScript
+  - UTC
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/UTC
+---
+<p>{{JSRef}}</p>
+
+<p>O método <strong><code>Date.UTC()</code></strong> aceita os mesmos parâmetros que o construtor mais longo de <strong><code>Date</code></strong> e retorna o total de milisegundos desde 1º de Janeiro de 1970 às 00:00:00 (horário universal). O valor retornado por <strong><code>Date.UTC()</code></strong> pode ser usado como parâmetro para criar uma instância de {{jsxref("Date")}}.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre><code>Date.UTC(<var>ano</var>, <var>mês</var>[, <var>dia</var>[, <var>hora</var>[, <var>minuto</var>[, <var>segundo</var>[, <var>milisegundo</var>]]]]])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>ano</code></dt>
+ <dd>Um valor inteiro representando o ano, após 1970.</dd>
+ <dt><code><var>mês</var></code></dt>
+ <dd>Um valor inteiro que representa o mês, começando com 0 para Janeiro até 11 para Dezembro.</dd>
+ <dt><code><var>dia</var></code></dt>
+ <dd>Opcional. Um valor inteiro entre 1 e 31 representando o dia do mês.</dd>
+ <dt><code><var>hora</var></code></dt>
+ <dd>Opcional. Um valor inteiro entre 0 e 23 representando a hora do dia.</dd>
+ <dt><code>minuto</code></dt>
+ <dd>Opcional. Um valor entre 0 e 59 representando os minutos.</dd>
+ <dt><code>segundo</code></dt>
+ <dd>Opcional. Um valor entre 0 e 59 representando os segundos.</dd>
+ <dt><code>milisegundo</code></dt>
+ <dd>Opcional. Um valor entre 0 e 999 representando os milisegundos.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><strong><code>UTC() </code></strong>recebe argumentos de uma data separados por vírgula e retorna um número representando o total de milisegundos entre o dia 1º de Janeiro de 1970 às 00:00:00 (horário universal) e a data e hora que você especificou.</p>
+
+<p>Você deve especificar o ano completo para o argumento ano. Por exemplo, 1998. Se o ano fornecido for um valor entre 0 e 99 o método irá converter este valor para o século 20 (1900 + ano); Por exemplo, se você utilizar 95, então o ano 1995 será utilizado.</p>
+
+<p>O método <code>UTC()<strong> </strong></code>se diferencia do construtor de<font face="Consolas, Liberation Mono, Courier, monospace"> </font>{{jsxref("Date")}} de duas maneiras:</p>
+
+<ul>
+ <li><code>Date.UTC()</code> utiliza o horário universal em vez do horário local.</li>
+ <li><code>Date.UTC() </code>retorna um valor inteiro em vez de uma instância de {{jsxref("Date")}}.</li>
+</ul>
+
+<p>Se você fornecer um argumento fora do intervalo esperado, o método UTC() atualiza os demais argumentos para permitir este valor. Por exemplo, se você utilizar 15 para mês, será adicionado 1 ao argumento ano (ano + 1) e será utilizado 3 para o argumento mês.</p>
+
+<p><code>UTC() </code>é um método estático, por conta disto você sempre irá chamar <code>Date.UTC()</code> em vez de chamar um método de um objeto {{jsxref("Date")}} que você tenha criado.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_Date.UTC" name="Example:_Using_Date.UTC">Utilizando <code>Date.UTC()</code></h3>
+
+<p>A seguinte expressão cria uma instância de {{jsxref("Date")}} utilizando UTC em vez do horário local:</p>
+
+<pre>var dataUniversal = new Date(Date.UTC(96, 11, 1, 0, 0, 0));
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<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-date.utc', 'Date.UTC')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.9.4.3', 'Date.UTC')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Date.parse()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/date/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/date/valueof/index.html
new file mode 100644
index 0000000000..a4e807b027
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/date/valueof/index.html
@@ -0,0 +1,69 @@
+---
+title: Date.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/Date/valueOf
+tags:
+  - Date
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - Referencia
+  - data
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Date/valueOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>valueOf()</code></strong> retorna o valor primitivo do objeto {{jsxref("Date")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/date-valueof.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>dateObj</var>.valueOf()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de milissegundos entre 1 de Janeiro de 1970 00:00:00 UTC e a data.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>valueOf()</code> retorna o valor primitivo do objeto {{jsxref("Date")}} como um tipo de dado numérico, o número de milissegundos desde a meia noite do dia 1 de Janeiro de 1970 UTC.</p>
+
+<p>Este método é funcionalmente equivalente ao método {{jsxref("Date.prototype.getTime()")}}.</p>
+
+<p>Este método é geralmente chamado internamente pelo JavaScript e não explícito em código.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_valueOf">Usando <code>valueOf()</code></h3>
+
+<pre class="brush: js notranslate">var x = new Date(56, 6, 17);
+var myVar = x.valueOf();      // atribui -424713600000 to myVar
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-date.prototype.valueof', 'Date.prototype.valueOf')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Date.valueOf")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+ <li>{{jsxref("Date.prototype.getTime()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/decodeuri/index.html b/files/pt-br/web/javascript/reference/global_objects/decodeuri/index.html
new file mode 100644
index 0000000000..46abadbb77
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/decodeuri/index.html
@@ -0,0 +1,99 @@
+---
+title: decodeURI()
+slug: Web/JavaScript/Reference/Global_Objects/decodeURI
+translation_of: Web/JavaScript/Reference/Global_Objects/decodeURI
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p><span class="seoSummary">A função <code><strong>decodeURI()</strong></code> decodifica um Uniform Resource Identifier (URI) criado anteriormente por {{jsxref("encodeURI", "encodeURI()")}} ou por uma rotina semelhante.</span></p>
+
+<div>{{EmbedInteractiveExample("pages/js/globalprops-decodeuri.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>decodeURI(<em>encodedURI</em>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>encodedURI</code></dt>
+ <dd>Um identificador de recurso uniforme codificado completo.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova string representando a versão não codificada do URI (Uniform Resource Identifier) ​​codificado fornecido.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<p>Lança uma exceção {{jsxref("URIError")}} ("sequência de URI malformada") quando o <code><em>encodedURI</em></code> contém sequências de caracteres inválidos.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Substitui cada sequência de escape no URI codificado pelo caractere que ele representa, mas não decodifica sequências de escape que não poderiam ter sido introduzidas por {{jsxref("encodeURI")}}. O caractere “<code>#</code>” não é decodificado a partir de sequência de escape.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Decodificando_uma_URL_Cyrillic">Decodificando uma URL Cyrillic</h3>
+
+<pre class="brush: js">decodeURI('https://developer.mozilla.org/ru/docs/JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B');
+// "https://developer.mozilla.org/ru/docs/JavaScript_шеллы"
+</pre>
+
+<h3 id="Captura_de_erros">Captura de erros</h3>
+
+<pre>try {
+  var a = decodeURI('%E0%A4%A');
+} catch(e) {
+  console.error(e);
+}
+
+// URIError: sequência de URI malformada</pre>
+
+<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>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.3.1', 'decodeURI')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-decodeuri-encodeduri', 'decodeURI')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-decodeuri-encodeduri', 'decodeURI')}}</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.decodeURI")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li>
+ <li>{{jsxref("encodeURI", "encodeURI()")}}</li>
+ <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/decodeuricomponent/index.html b/files/pt-br/web/javascript/reference/global_objects/decodeuricomponent/index.html
new file mode 100644
index 0000000000..71f6fcb6eb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/decodeuricomponent/index.html
@@ -0,0 +1,118 @@
+---
+title: decodeURIComponent()
+slug: Web/JavaScript/Reference/Global_Objects/decodeURIComponent
+translation_of: Web/JavaScript/Reference/Global_Objects/decodeURIComponent
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p>O método <code><strong>decodeURIComponent()</strong></code> decodifica um componente Identificador Uniforme de Recursos (URI) criado anteriormente por um {{jsxref("encodeURIComponent")}} ou por uma rotina semelhante.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>decodeURIComponent(<em>encodedURI</em>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>encodedURI</code></dt>
+ <dd>Um componente codificado de um Identificador Uniforme de Recursos.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Substitui cada sequência escapada no componente URI codificado com o caractere que a representa.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Decodificando_um_componente_URL_Cirílico">Decodificando um componente URL Cirílico</h3>
+
+<pre class="brush: js">decodeURIComponent("JavaScript_%D1%88%D0%B5%D0%BB%D0%BB%D1%8B");
+// "JavaScript_шеллы"
+</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('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.3.2', 'decodeURIComponent')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-decodeuricomponent-encodeduricomponent', 'decodeURIComponent')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("decodeURI")}}</li>
+ <li>{{jsxref("encodeURI")}}</li>
+ <li>{{jsxref("encodeURIComponent")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/encodeuri/index.html b/files/pt-br/web/javascript/reference/global_objects/encodeuri/index.html
new file mode 100644
index 0000000000..362493efd9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/encodeuri/index.html
@@ -0,0 +1,122 @@
+---
+title: encodeURI()
+slug: Web/JavaScript/Reference/Global_Objects/encodeURI
+tags:
+  - Codificação
+  - JavaScript
+  - Texto
+  - URI
+  - URL
+  - encodeURI
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p>A função <code><strong>encodeURI()</strong></code> codifica a <a href="/en-US/docs/Glossary/URI">URI</a> substituindo cada instância de certos caracteres por um, dois, três ou quatro sequências de escape representando a codificação <a href="/en-US/docs/Glossary/UTF-8">UTF-8</a> do caracter (será somente quatro sequências de escape para caracteres compostos de dois caracteres substitutos).</p>
+
+<div>{{EmbedInteractiveExample("pages/js/globalprops-encodeuri.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>encodeURI(<var>URI</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>URI</var></code></dt>
+ <dd>Uma URI completa.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma nova cadeia de caracteres representando a cadeia de caracteres provida, codificada como uma URI.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função <code>encodeURI()</code> não codifica caracteres que possuem significado especial (caracteres reservados) para a URI. O exemplo seguinte mostra todas as partes que o "esquema" da URI pode possivelmente conter. Note como certos caracteres são usados para dar significado especial:</p>
+
+<pre class="notranslate">http://username:password@www.example.com:80/path/to/file.php?foo=316&amp;bar=this+has+spaces#anchor</pre>
+
+<p>Consequentemente, <code>encodeURI()</code> <strong>não</strong> codifica caracteres que são necessários para formular uma URI completa. Também, <code>encodeURI()</code> <strong>não</strong> codifica alguns caracteres adicionais, conhecidos como "marcas não reservadas (unreserved marks)", que não tem propósito reservado mas são permitidos na URI "como são". (Veja <a href="https://www.ietf.org/rfc/rfc2396.txt">RFC2396)</a></p>
+
+<p><code>encodeURI()</code> escapa todos os caracteres <strong>exceto</strong>:</p>
+
+<pre class="notranslate"><strong>Não escapado</strong>:
+
+    A-Z a-z 0-9 ; , / ? : @ &amp; = + $ - _ . ! ~ * ' ( ) #<code>
+</code>
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="encodeURI_vs_encodeURIComponent">encodeURI vs encodeURIComponent</h3>
+
+<p><code>encodeURI()</code> se difere de {{jsxref("encodeURIComponent", "encodeURIComponent()")}} como a seguir:</p>
+
+<pre class="brush: js notranslate">var set1 = ";,/?:@&amp;=+$#"; // Caracteres reservados
+var set2 = "-_.!~*'()";   // Marcas não reservadas
+var set3 = "ABC abc 123"; // Caracteres alfanuméricos + Espaço
+
+console.log(encodeURI(set1)); // ;,/?:@&amp;=+$#
+console.log(encodeURI(set2)); // -_.!~*'()
+console.log(encodeURI(set3)); // ABC%20abc%20123 (o espaço é codificado como %20)
+
+console.log(encodeURIComponent(set1)); // %3B%2C%2F%3F%3A%40%26%3D%2B%24%23
+console.log(encodeURIComponent(set2)); // -_.!~*'()
+console.log(encodeURIComponent(set3)); // ABC%20abc%20123 (o espaço é codificado como %20)
+</pre>
+
+<p>Note que <code>encodeURI()</code> por si só não pode formar requisições <a href="/en-US/docs/Web/HTTP/Methods/GET" title="The HTTP GET method requests a representation of the specified resource. Requests using GET should only retrieve data."><code>GET</code></a> e <a href="/en-US/docs/Web/HTTP/Methods/POST" title="The HTTP POST method sends data to the server. The type of the body of the request is indicated by the Content-Type header."><code>POST</code></a>, como para <a href="/en-US/docs/Web/API/XMLHttpRequest" title="Use XMLHttpRequest (XHR) objects to interact with servers. You can retrieve data from a URL without having to do a full page refresh. This enables a Web page to update just part of a page without disrupting what the user is doing."><code>XMLHttpRequest</code></a>, porque <code>"&amp;"</code>, <code>"+"</code>, e <code>"="</code> não são codificados, que são tratados como caracteres especiais em requisições <code>GET</code> e <code>POST</code>. <code>encodeURIComponent()</code>, entretanto, codifica esses caracteres.</p>
+
+<h3 id="Codificando_um_substituto_solitário_alto_joga">Codificando um substituto solitário alto joga</h3>
+
+<p>Um {{jsxref("URIError")}} será jogado se uma tentativa de codificar um substituto que não é parte de um par alto-baixo, e.g.,</p>
+
+<pre class="brush: js notranslate">// par alto-baixo ok
+console.log(encodeURI('\uD800\uDFFF'));
+
+// substituto alto solitário joga "URIError: malformed URI sequence"
+console.log(encodeURI('\uD800'));
+
+// substituto baixo solitário joga "URIError: malformed URI sequence"
+console.log(encodeURI('\uDFFF'));</pre>
+
+<h3 id="Codificando_para_IPv6">Codificando para IPv6</h3>
+
+<p>Se você deseja seguir a <a href="http://tools.ietf.org/html/rfc3986">RFC3986</a> mais recente para URLs, que faz colchetes ser reservado (para <a href="/en-US/docs/Glossary/IPv6">IPv6</a>) e então não será codificado quando formando algo que possa ser parte da URL (como o host), o seguinte código pode ajudar:</p>
+
+<pre class="brush: js notranslate">function fixedEncodeURI(str) {
+    return encodeURI(str).replace(/%5B/g, '[').replace(/%5D/g, ']');
+}</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-encodeuri-uri', 'encodeURI')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.encodeURI")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("decodeURI", "decodeURI()")}}</li>
+ <li>{{jsxref("encodeURIComponent", "encodeURIComponent()")}}</li>
+ <li>{{jsxref("decodeURIComponent", "decodeURIComponent()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/encodeuricomponent/index.html b/files/pt-br/web/javascript/reference/global_objects/encodeuricomponent/index.html
new file mode 100644
index 0000000000..9d08433bfa
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/encodeuricomponent/index.html
@@ -0,0 +1,159 @@
+---
+title: encodeURIComponent()
+slug: Web/JavaScript/Reference/Global_Objects/encodeURIComponent
+translation_of: Web/JavaScript/Reference/Global_Objects/encodeURIComponent
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p>O método <code><strong>encodeURIComponent()</strong></code> codifica  uma URI (Identificador recurso uniforme) substituindo cada ocorrência de determinados caracteres por um, dois, três, ou quatro seqüências de escape que representam a codificação UTF-8 do caractere (só será quatro seqüências de escape para caracteres compostos por dois caracteres "substituto").</p>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="syntaxbox">encodeURIComponent(str);</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>str</code></dt>
+ <dd>String. Uma sequência URI.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>encodeURIComponent</code> escapa todos os caracteres, exceto: alfabeto, dígitos decimais, <code>- _ . ! ~ * ' ( )</code></p>
+
+<p>Note-se que um{{jsxref("URIError")}} será gerada se uma tentativas para codificar um substituto que não faz parte de um par de alta-baixa, por exemplo,</p>
+
+<pre class="brush: js">// high-low par ok
+console.log(encodeURIComponent('\uD800\uDFFF'));
+
+// lone high surrogate throws "URIError: malformed URI sequence"
+console.log(encodeURIComponent('\uD800'));
+
+// lone low surrogate throws "URIError: malformed URI sequence"
+console.log(encodeURIComponent('\uDFFF'));
+</pre>
+
+<p>Para previnir requisões inesperadas ao servidor, deve-se chamar <code>encodeURIComponent</code> ou qualquer parâmetro fornecido pelo usuário que será passado como parte da URI. Por exemplo, um usuário poderia digitar "<code>Thyme &amp;time=again</code>" para uma variável <code>commentario</code>. Ao não usar <code>encodeURIComponent</code> nessa variável irá ser obetido <code>commentario=Thyme%20&amp;time=again</code>. Note que o ampersa  e o sinal de igual marcam um novo par de chave e valor. Então ao invés de ter um POST com a chave <code>commentario</code> igual a "<code>Thyme &amp;time=again</code>", tem-se chaves em  POST, uma igual a "<code>Thyme </code>" e outra (<code>time</code>) igual a <code>again</code>.</p>
+
+<p>Para <a href="http://www.whatwg.org/specs/web-apps/current-work/multipage/association-of-controls-and-forms.html#application/x-www-form-urlencoded-encoding-algorithm"><code>application/x-www-form-urlencoded</code></a>, espaços são substituídos por '+', então pode-se querer seguir um <code>encodeURIComponent</code> substituição com uma substituição adicional de "%20" com "+".</p>
+
+<p>Para ser mais rigoroso à aderência da <a class="external" href="http://tools.ietf.org/html/rfc3986">RFC 3986</a> (qual reserva !, ', (, ), e *), mesmo que esses caracteres não tenham usos formalizados de delimitação de URI, o seguinte pode ser usado com segurança:</p>
+
+<pre class="brush: js">function ajustadoEncodeURIComponent (str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+    return '%' + c.charCodeAt(0).toString(16);
+  });
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>O exemplo seguinte provê o encoding especial requerido pelo UTF-8 nos parâmetros <code>Content-Disposition</code> e <code>Link</code> no cabeçalho de uma Response (e.g., UTF-8 filenames):</p>
+
+<pre class="brush: js">var fileName = 'my file(2).txt';
+var header = "Content-Disposition: attachment; filename*=UTF-8''"
+             + encodeRFC5987ValueChars(fileName);
+
+console.log(header);
+// logs "Content-Disposition: attachment; filename*=UTF-8''my%20file%282%29.txt"
+
+
+function encodeRFC5987ValueChars (str) {
+    return encodeURIComponent(str).
+        // Note that although RFC3986 reserves "!", RFC5987 does not,
+        // so we do not need to escape it
+        replace(/['()]/g, escape). // i.e., %27 %28 %29
+        replace(/\*/g, '%2A').
+            // The following are not required for percent-encoding per RFC5987,
+            // so we can allow for a little better readability over the wire: |`^
+            replace(/%(?:7C|60|5E)/g, unescape);
+}
+</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">Comentario</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição Inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.3.4', 'encodeURIComponent')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-encodeuricomponent-uricomponent', 'encodeURIComponent')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_-_Browser">Compatibilidade - Browser</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("decodeURI")}}</li>
+ <li>{{jsxref("encodeURI")}}</li>
+ <li>{{jsxref("decodeURIComponent")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/error/index.html b/files/pt-br/web/javascript/reference/global_objects/error/index.html
new file mode 100644
index 0000000000..41cc7e5bb8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/error/index.html
@@ -0,0 +1,229 @@
+---
+title: Error
+slug: Web/JavaScript/Reference/Global_Objects/Error
+tags:
+  - Custom Error
+  - Erro
+  - Error
+  - JavaScript
+  - Reference
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Error
+---
+<div>{{JSRef}}</div>
+
+<p>O construtor de <strong><code>Error</code></strong> cria um objeto de erro. Instâncias de objetos <code>Error</code> são lançadas quando erros de tempo de execução ocorrem. O objeto <code>Error</code> também pode ser usado como objeto base para exceções definidas pelo usuário. Veja abaixo tipos de erro padrões embutidos.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">new Error([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>message</code></dt>
+ <dd>Opcional. Descrição do erro legível para humanos.</dd>
+ <dt><code>fileName</code> {{non-standard_inline}}</dt>
+ <dd>Opcional. O valor da propriedade <code>fileName</code>  no objeto de erro criado. O padrão é o nome do arquivo contendo o código que chamou o construtor de <code>Error()</code>.</dd>
+ <dt><code>lineNumber</code> {{non-standard_inline}}</dt>
+ <dd>Opcional. O valor da propriedade <code>lineNumber</code> no objeto de <code>Error</code> criado. O padrão é o número da linha contendo a invocação do construtor <code>Error()</code>.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Erros em tempo de execução resultam em novos objetos <code>Error</code> sendo criados e lançados.</p>
+
+<p>Esta página documenta o uso do objeto <code>Error</code> em si e seu uso como uma função construtora. Para uma lista de propriedades e métodos herdados por instâncias de <code>Error</code>, veja {{jsxref("Error.prototype")}}.</p>
+
+<h3 id="Tipos_de_erro">Tipos de erro</h3>
+
+<p>Além do construtor genérico de <code>Error</code>, existem outros seis construtores principais de erro  no JavaScript. Para exceções em <em>client-side</em>, veja <a href="/en-US/docs/Web/JavaScript/Guide/Statements#Exception_Handling_Statements">Excessões na captura de Instruções</a>.</p>
+
+<dl>
+ <dt>{{jsxref("EvalError")}}</dt>
+ <dd>Cria uma instância representando um erro que ocorre na função global. {{jsxref("Global_Objects/eval", "eval()")}}.</dd>
+ <dt>{{jsxref("InternalError")}} {{non-standard_inline}}</dt>
+ <dd>Cria uma instância representando um erro que ocorre quando um erro interno na <em>engine</em> do JavaScript é lançado. Ex: "too much recursion".</dd>
+ <dt>{{jsxref("RangeError")}}</dt>
+ <dd>Cria uma instância representando um erro que ocorre quando um valor ou parâmetro numérico está fora de seus limites válidos.</dd>
+ <dt>{{jsxref("ReferenceError")}}</dt>
+ <dd>Cria uma instância representando um erro que ocorre ao de-referenciar uma referência inválida.</dd>
+ <dt>{{jsxref("SyntaxError")}}</dt>
+ <dd>Cria uma instância representando um erro que ocorre ao fazer o <em>parse</em> do código em {{jsxref("Global_Objects/eval", "eval()")}}.</dd>
+ <dt>{{jsxref("TypeError")}}</dt>
+ <dd>Cria uma instância representando um erro que ocorre quando uma variável ou parâmetro não é de um tipo válido.</dd>
+ <dt>{{jsxref("URIError")}}</dt>
+ <dd>Cria uma instância representando um erro que ocorre quando são passados parâmetros inválidos para {{jsxref("Global_Objects/encodeURI", "encodeURI()")}} ou {{jsxref("Global_Objects/decodeURI", "decodeURI()")}}.</dd>
+</dl>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("Error.prototype")}}</dt>
+ <dd>Permite a criação de propriedades para instâncias de <code>Error</code>.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<p>O objeto <code>Error</code> global não contém métodos próprios, entretanto, ele herda alguns métodos através da cadeia de <em>prototypes</em>.</p>
+
+<h2 id="Instâncias_de_Error"><code>Instâncias de Error</code></h2>
+
+<div>{{page('pt-BR/docs/JavaScript/Reference/Global_Objects/Error/prototype', 'Description')}}</div>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<div>{{page('pt-BR/docs/JavaScript/Reference/Global_Objects/Error/prototype', 'Properties')}}</div>
+
+<h3 id="Métodos_2">Métodos</h3>
+
+<div>{{page('pt-BR/docs/JavaScript/Reference/Global_Objects/Error/prototype', 'Methods')}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Lançando_um_erro_genérico">Lançando um erro genérico</h3>
+
+<p>Geralmente você cria um objeto <code>Error</code> com a intenção de lançá-lo usando a palavra-chave {{jsxref("Statements/throw", "throw")}}. Você pode capturar o erro usando uma construção de {{jsxref("Statements/try...catch", "try...catch")}}:</p>
+
+<pre class="brush: js">try {
+  throw new Error('Oooops!');
+} catch (e) {
+  alert(e.name + ': ' + e.message);
+}
+</pre>
+
+<h3 id="Capturando_um_erro_específico">Capturando um erro específico</h3>
+
+<p>Você pode escolher por capturar apenas tipos de erro específicos testando o tipo do erro com a propriedade {{jsxref("Object.prototype.constructor", "constructor")}} de erro ou, se você está escrevendo para <em>engines</em> de JavaScript modernas, a palavra-chave {{jsxref("Operators/instanceof", "instanceof")}}:</p>
+
+<pre class="brush: js">try {
+  Objeto.Metodo();
+} catch (e) {
+  if (e instanceof EvalError) {
+    alert(e.name + ': ' + e.message);
+  } else if (e instanceof RangeError) {
+    alert(e.name + ': ' + e.message);
+  }
+  // ... etc
+}
+</pre>
+
+<h3 id="Tipos_de_erro_customizados">Tipos de erro customizados</h3>
+
+<p>Você pode escolher definir seus próprios tipos de erro derivando de <code>Error</code> para conseguir usar <code>throw new MeuErro()</code> e usar <code>instanceof MeuErro </code>para checar o tipo de erro na captura da exceção. A forma comum para isso está demonstrada abaixo</p>
+
+<div class="warning">
+<p>Note que as instâncias <code>MeuErro</code> lançadas vão reportar valores de <code>lineNumber</code> e <code>fileName</code> incorretos, ao menos no Firefox.</p>
+</div>
+
+<p>Veja também <a href="http://stackoverflow.com/questions/1382107/whats-a-good-way-to-extend-error-in-javascript">"esta discussão no Stackoverflow (em inglês): What's a good way to extend Error in JavaScript?"</a>.</p>
+
+<pre class="brush: js">// Cria um novo objeto que herda o construtor de Error através do prototype.
+function MeuErro(message) {
+  this.name = 'MeuErro';
+  this.message = message || 'Mensagem de erro padrão';
+  this.stack = (new Error()).stack;
+}
+MeuErro.prototype = Object.create(MeuErro.prototype);
+MeuErro.prototype.constructor = MeuErro;
+
+try {
+  throw new MeuErro();
+} catch (e) {
+  console.log(e.name);     // 'MeuErro'
+  console.log(e.message);  // 'Mensagem de erro padrão'
+}
+
+try {
+  throw new MeuErro('Mensagem customizada');
+} catch (e) {
+  console.log(e.name);     // 'MeuErro'
+  console.log(e.message);  // 'Mensagem customizada'
+}</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11', 'Error')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-error-objects', 'Error')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browser">Compatibilidade de browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype")}}</li>
+ <li>{{jsxref("Statements/throw", "throw")}}</li>
+ <li>{{jsxref("Statements/try...catch", "try...catch")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/error/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/error/tosource/index.html
new file mode 100644
index 0000000000..2a6ed43803
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/error/tosource/index.html
@@ -0,0 +1,58 @@
+---
+title: Error.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Error/toSource
+tags:
+  - JavaScript
+  - Não padronizado
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O método <code><strong>toSource()</strong></code> retorna código que pode resultar no mesmo erro.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>e</var>.toSource()</pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma string contendo o código fonte do erro.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toSource">Usando toSource</h3>
+
+<p>Chamando método <code>toSource</code> de uma instância {{jsxref("Error")}} (incluindo<em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Error_types"> NativeErrors</a></em>) irá retornar uma string contendo o código fonte do erro. Essa string pode ser avaliada para criar (aproximadamente) um objeto igual. Naturalmente, a string contendo o fonte segue a estrutura do construtor {{jsxref("Error")}}. Por exemplo:</p>
+
+<pre class="brush: js notranslate">(new<em>name</em>(<em>message</em> ,<em>fileName</em>,<em>lineNumber</em>))
+</pre>
+
+<p>onde estes atributos correspondem as respectivas propriedades da instância do erro.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> Fique alerta que as propriedades usadas pelo método <code>toSource</code> na criação da string são mutáveis e podem não refletir precisamente a função utilizada para criar a instância do erro ou nome de arquivo ou número de linha onde o erro atual ocorreu.</p>
+</div>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de nenhum padrão.</p>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.toSource")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.fileName")}}</li>
+ <li>{{jsxref("Error.prototype.lineNumber")}}</li>
+ <li>{{jsxref("Error.prototype.message")}}</li>
+ <li>{{jsxref("Error.prototype.name")}}</li>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/error/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/error/tostring/index.html
new file mode 100644
index 0000000000..80aba76e10
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/error/tostring/index.html
@@ -0,0 +1,100 @@
+---
+title: Error.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Error/toString
+tags:
+  - JavaScript
+  - Method
+  - Prototipo
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Error/toString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>toString()</strong></code> retorna uma string representando o objeto {{jsxref("Error")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>e</var>.toString()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>A string representando o objeto {{jsxref("Error")}} especificado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O objeto {{jsxref("Error")}} sobrescreve o método {{jsxref("Object.prototype.toString()")}} herdado por todos os objetos. Sua semântica é a seguinte (assumindo que {{jsxref("Object")}} e {{jsxref("String")}} tem seus valores originais):</p>
+
+<pre class="brush: js notranslate">Error.prototype.toString = function() {
+  'use strict';
+
+  var obj = Object(this);
+  if (obj !== this) {
+    throw new TypeError();
+  }
+
+  var name = this.name;
+  name = (name === undefined) ? 'Error' : String(name);
+
+  var msg = this.message;
+  msg = (msg === undefined) ? '' : String(msg);
+
+  if (name === '') {
+    return msg;
+  }
+  if (msg === '') {
+    return name;
+  }
+
+  return name + ': ' + msg;
+};
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toString">Usando toString()</h3>
+
+<pre class="brush: js notranslate">var e = new Error('fatal error');
+console.log(e.toString()); // 'Error: fatal error'
+
+e.name = undefined;
+console.log(e.toString()); // 'Error: fatal error'
+
+e.name = '';
+console.log(e.toString()); // 'fatal error'
+
+e.message = undefined;
+console.log(e.toString()); // ''
+
+e.name = 'hello';
+console.log(e.toString()); // 'hello'
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-error.prototype.tostring', 'Error.prototype.toString')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Error.toString")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Error.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/escape/index.html b/files/pt-br/web/javascript/reference/global_objects/escape/index.html
new file mode 100644
index 0000000000..b966913b6d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/escape/index.html
@@ -0,0 +1,127 @@
+---
+title: escape()
+slug: Web/JavaScript/Reference/Global_Objects/escape
+translation_of: Web/JavaScript/Reference/Global_Objects/escape
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<div>A função obsoleta <code><strong>escape() </strong>retorna uma nova string com</code><span class="short_text" id="result_box" lang="pt"><span> </span><span>certos</span> <span>caracteres</span> <span>substituídos por sua sequência hexadecial. Use </span></span>{{jsxref("encodeURI")}} ou {{jsxref("encodeURIComponent")}} em seu lugar.</div>
+
+<div> </div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>escape(str)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>str</code></dt>
+ <dd>Uma string para ser codificada.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função <strong><code>escape </code></strong><code>é uma propriedade do </code><em>global object. </em>Caracteres especiais são codificados, com a exceção de: @*_+-./</p>
+
+<p>O formato hexadecimal de caracteres, que o valor unitário do código é <strong>0xFF or less, </strong>é uma sequência de escape de 2 digitos: %xx. Para caracteres com um código unitário maior, uma sequência de 4 digitos %<strong>u</strong>xxxx é usada.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">escape("abc123");     // "abc123"
+escape("äöü");        // "%E4%F6%FC"
+escape("ć");          // "%u0107"
+
+// Caracteres Especiais
+escape("@*_+-./");    // "@*_+-./"</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-B.2.1', 'escape')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td><span class="short_text" id="result_box" lang="pt"><span>Definido no </span><span>(informativo</span><span>) de c</span><span>ompatibilidade</span> <span>Anexo</span> <span>B</span></span></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-escape-string', 'escape')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td><span id="result_box" lang="pt"><span>Definido no</span> <span>(</span><span>normativo)</span> <span>Anexo</span> <span>B</span> <span>para recursos</span> <span>adicionais do</span> <span>ECMAScript</span> <span>para navegadores da web</span></span></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-escape-string', 'escape')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td><span id="result_box" lang="pt"><span>Definido no</span> <span>(</span><span>normativa)</span> <span>Anexo</span> <span>B</span> <span>para recursos</span> <span>adicionais do</span> <span>ECMAScript</span> <span>para navegadores da web</span></span></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("encodeURI")}}</li>
+ <li>{{jsxref("encodeURIComponent")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/eval/index.html b/files/pt-br/web/javascript/reference/global_objects/eval/index.html
new file mode 100644
index 0000000000..f4e0044f50
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/eval/index.html
@@ -0,0 +1,255 @@
+---
+title: eval()
+slug: Web/JavaScript/Reference/Global_Objects/eval
+translation_of: Web/JavaScript/Reference/Global_Objects/eval
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>A função <code><strong>eval()</strong></code> computa um código JavaScript representado como uma string.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="brush: js"><code>eval(<em>string</em>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>string</code></dt>
+ <dd>Uma sequência de caracteres que representa uma expressão JavaScript, declaração, ou sequência de declarações. A expressão pode incluir variáveis e propriedades de objetos existentes.</dd>
+</dl>
+
+
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>É o valor computado do código passado para a função. Se o valor estiver vazio, retornará {{jsxref("undefined")}}.</p>
+
+
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><code>eval() é uma função de propriedade do objeto global (window)</code>.</p>
+
+<p>O argumento da função <code>eval()</code> é uma string. Se a string representa uma expressão, <code>eval()</code> avalia a expressão. Se o argumento representa uma ou mais declarações em JavaScript, <code>eval()</code> avalia as declarações. Não chame o <code>eval()</code> para avaliar uma expressão aritmética; JavaScript avalia expressões aritméticas automaticamente.</p>
+
+<p>Se você construir uma expressão aritmética como uma string, você pode usar <code>eval()</code> para calcular o resultado depois. Por exemplo, suponha que você tenha uma variável x. Você pode adiar a avaliação de uma expressão envolvendo x atribuindo o valor de string da expressão, dizer <code>"3 * x + 2"</code>, a uma variável, e, em seguida, chamando <code>eval()</code> em um ponto posterior no seu script.</p>
+
+<p>Se o argumento de <code>eval()</code> não é uma string, <code>eval()</code> retorna o argumento inalterado. No exemplo a seguir, o construtor <code>String</code> é especificado, e <code>eval()</code> retorna um objeto <code>String</code> em vez de avaliar a string.</p>
+
+<pre class="brush:js">eval(new String("2 + 2")); // retorna um objeto String contendo "2 + 2"
+eval("2 + 2");             // retorna 4
+</pre>
+
+<p>Você pode contornar esta limitação de forma genérica usando <code>toString()</code>.</p>
+
+<pre class="brush:js">var expression = new String("2 + 2");
+eval(expression.toString()); // retorna 4
+</pre>
+
+<p>Se você usar a função <code>eval</code> <em>indiretamente</em>, invocando-a por outra referência além de <code>eval</code>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-10.4.2">a partir do ECMAScript 5</a> funciona no escopo global ao invés do escopo local. Significa que, por exemplo, aquelas declarações de funções criam funções globais e que o código que está sendo avaliado não tem acesso às variáveis locais dentro do escopo onde está sendo chamada.</p>
+
+<pre class="brush: js"><code>function test() {
+  var x = 2, y = 4;
+  console.log(eval('x + y'));  // Chamada direta, usa o escopo local, resulta em 6
+  var geval = eval; // equivalente a chamar eval no escopo global
+  console.log(geval('x + y')); // Chamada indireta, usa o escopo global, lança uma exceção ReferenceError porque `x` não foi declarado
+  (0, eval)('x + y'); // outro exemplo de chamada indireta
+}</code></pre>
+
+<h2 id="Don.27t_use_eval.21" name="Don.27t_use_eval.21"><a name="dont-use-it">Nunca use <code>eval</code>!</a></h2>
+
+<p><code>eval()</code> é uma função perigosa, que executa o código passado com os privilégios do caller. Se você executar o <code>eval() </code>com uma sequência de caracteres que podem ser afetados por uma parte maliciosa, você pode acabar executando código malicioso na máquina do usuário com as permissões da sua página/extensão. Mais importante ainda, o código de terceiros pode ver o escopo em que <code>eval()</code> foi chamado, o que pode levar a possíveis ataques como  {{jsxref("Global_Objects/Function", "Function")}} não é suscetível.</p>
+
+<p><code>eval()</code> é geralmente mais lento do que as alternativas, uma vez que tem de invocar o interpretador JS, enquanto muitos outros construtores são otimizados por <em>engines</em> de JS modernos.</p>
+
+<p>Os interpretadores modernos convertem javascript em código de máquina. Resumindo, o nome das variáveis será desmanchado. Portanto, o uso de <code>eval</code> forçará o navegador a fazer buscas caras para descobrir o endereço e seu valor no código de máquina. Além disso, novos valores podem ser introduzidos em <code>eval</code> como mudanças no tipo da variável, fazendo o navegador recalcular todo o código de máquina gerado anteriormente. Felizmente, existem alternativas mais seguras (e rápidas) ao <code>eval()</code> para usos comuns.</p>
+
+<h3 id="Accessing_member_properties" name="Accessing_member_properties">Acessando propriedades dos membros</h3>
+
+<p>Você não deve utilizar <code>eval()</code> para converter nomes de propriedades em propriedades. Considere o seguinte exemplo onde as propriedades do objeto a ser acessado não são conhecidas até o código ser executado. Isso pode ser feito com eval:</p>
+
+<pre class="brush:js">var obj = { a: 20, b: 30 };
+var propname = getPropName();  //retorna "a" ou "b"
+
+eval( "var result = obj." + propname );
+</pre>
+
+<p>No entanto, <code>eval()</code> não é necessário aqui. De fato, sua utilização não é recomendada. Ao invés disso, utilize os <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Member_Operators" title="JavaScript/Reference/Operators/Member_Operators">operadores de acesso</a>, que são mais rápidos e seguros:</p>
+
+<pre class="brush:js">var obj = { a: 20, b: 30 };
+var propname = getPropName();  //retorna "a" ou "b"
+var result = obj[ propname ];  //  obj[ "a" ] é o mesmo como obj.a
+</pre>
+
+<h3 id="Use_functions_instead_of_evaluating_snippets_of_code" name="Use_functions_instead_of_evaluating_snippets_of_code">Utilize funções ao invés de avaliar snippets de código</h3>
+
+<p>JavaScript possui <a class="external" href="http://en.wikipedia.org/wiki/First-class_function" title="http://en.wikipedia.org/wiki/First-class_function">first-class functions</a>, o que significa que você pode passar os argumentos para outras APIs, armazená-los em variáveis e propriedades de objeto, e assim por diante. Muitas APIs de DOM foram desenvolvidas com isso em mente, então você pode (e deve) escrever:</p>
+
+<pre class="brush: js">// ao invés de setTimeout(" ... ", 1000) use:
+setTimeout(function() { ... }, 1000);
+
+// ao invés de elt.setAttribute("onclick", "...") use:
+elt.addEventListener("click", function() { ... } , false); </pre>
+
+<p><a href="/en-US/docs/Web/JavaScript/Guide/Closures" title="JavaScript/Guide/Closures">Closures</a> são úteis como forma de criar funcções parametrizáveis sem concatenar strings.</p>
+
+<h3 id="Parsing_JSON_converting_strings_to_JavaScript_objects" name="Parsing_JSON_(converting_strings_to_JavaScript_objects)">Analisando JSON (convertendo string para objetos JavaScript)</h3>
+
+<p>Se a string para a qual você está chamando o <code>eval() contém dados </code>(por exemplo, um array: <code>"[1, 2, 3]"</code>),  ao invés de código, você deve considerar mudar para <a href="/en-US/docs/JSON" title="JSON">JSON</a>, que permite a string usar um subconjunto de sintaxe Javascript para representar dados. Veja também <a href="/en-US/docs/Downloading_JSON_and_JavaScript_in_extensions" title="Downloading_JSON_and_JavaScript_in_extensions">Downloading JSON and JavaScript in extensions</a>.</p>
+
+<p>Perceba que como a sintaxe JSON é limitada comparada com a sintaxe JavaScript, muitos literais JavaScript válidos não serão analisados como JSON. Por exemplo, trailing commas não são permitidas em JSON, e nomes de propriedades (keys) em literais de objetos devem ser colocados entre aspas. Certifique-se de usar um serializados JSON para gerar strings que serão analisadas como JSON mais tarde.</p>
+
+<h3 id="Pass_data_instead_of_code" name="Pass_data_instead_of_code">Passar dados em vez de códigos</h3>
+
+<p>Por exemplo, uma extensão concebida para raspar conteúdos de páginas web pode ter as regras de raspagem definidas no <a href="/en-US/docs/XPath" title="XPath">XPath</a> em vez de código JavaScript.</p>
+
+<h3 id="Run_code_with_limited_privileges" name="Run_code_with_limited_privileges">Rodando o código com privilégios limitados</h3>
+
+<p>Se você precisa executar o código, considere executá-lo com privilégios limitados. Esse conselho se aplica principalmente para extensões e aplicações XUL, que podem usar <a href="/en-US/docs/Components.utils.evalInSandbox" title="Components.utils.evalInSandbox">Components.utils.evalInSandbox</a> para obter o resultado.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<p>Os exemplos a seguir mostram o retorno do <a href="/en-US/docs/Web/API/document.write"><code>document.write</code></a>. No JavaScript rodando no server-side, você pode obter o mesmo resultado chamando o método <code>write()ao invés</code> de usar o <code>document.write()</code>.</p>
+
+<h3 id="Example_Using_eval" name="Example:_Using_eval">Exemplo: Usando <code>eval</code></h3>
+
+<p>No código a seguir, ambas as declarações contendo <code>eval()</code> retornam 42. A primeira avalia a string "<code>x + y + 1</code>"; a segunda avalia a string "<code>42</code>".</p>
+
+<pre class="brush:js">var x = 2;
+var y = 39;
+var z = "42";
+eval("x + y + 1"); // returns 42
+eval(z);           // returns 42
+</pre>
+
+<h3 id="Example_Using_eval_to_evaluate_a_string_of_JavaScript_statements" name="Example:_Using_eval_to_evaluate_a_string_of_JavaScript_statements">Examplo: Using <code>eval</code> to evaluate a string of JavaScript statements</h3>
+
+<p>O exemplo a seguir usa <code>eval()</code> para avaliar a string <code>str</code>. Essa string consiste de instruções JavaScript que abrem uma caixa de diálogo de alerta e atribuem ao <code>z</code> o valor de 42 se <code>x</code> for cinco, e do contrário, atribui 0 a <code>z</code>. Quando a segunda instrução é executada, <code>eval()</code> fará com que essas instruções sejam executadas e também irá avaliar o conjunto de instruções e retornará o valor atribuído a z.</p>
+
+<pre class="brush:js">var x = 5;
+var str = "if (x == 5) {alert('z is 42'); z = 42;} else z = 0; ";
+
+document.write("&lt;P&gt;z is ", eval(str));</pre>
+
+<h3 id="Return_value" name="Return_value">Exemplo: A última expressão é avaliada</h3>
+
+<p><code>eval()</code> retorna o valor da última expressão avaliada.</p>
+
+<pre class="brush:js">var str = "if ( a ) { 1+1; } else { 1+2; }";
+var a = true;
+var b = eval(str);  // returns 2
+
+alert("b is : " + b);
+
+a = false;
+b = eval(str);  // returns 3
+
+alert("b is : " + b);</pre>
+
+<h3 id="Exemplo_avaliar_uma_string_definindo_a_função_necessária_and_como_prefixo_e_sufixo">Exemplo: avaliar uma string definindo a função necessária "(" and ")" como prefixo e sufixo</h3>
+
+<pre class="brush:js" style="font-size: 14px;">var fctStr1 = "function a() {}"
+var fctStr2 = "(function a() {})"
+var fct1 = eval(fctStr1)  // return undefined
+var fct2 = eval(fctStr2)  // return a function
+</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>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.2.1', 'eval')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-eval-x', 'eval')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="See_Also" name="See_Also">Gecko-specific notes</h3>
+
+<ul>
+ <li>Historicamente <code>eval()</code> tinha um segundo argumento opcional , especificando um objeto em cujo o contexto a validação seria realizada. Esse argumento não era padronizado e foi removido do SpiderMonkey no Gecko 1.9.1 (Firefox 3.5). See {{ bug(442333) }}.</li>
+</ul>
+
+<h2 id="See_Also" name="See_Also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/uneval", "uneval()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Member_Operators">Member operators</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/evalerror/index.html b/files/pt-br/web/javascript/reference/global_objects/evalerror/index.html
new file mode 100644
index 0000000000..d938b83d8f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/evalerror/index.html
@@ -0,0 +1,163 @@
+---
+title: EvalError
+slug: Web/JavaScript/Reference/Global_Objects/EvalError
+tags:
+  - Desenvolvimento Web
+  - Erro
+  - EvalError
+  - JS
+  - JavaScript
+  - Referencia
+  - Web
+translation_of: Web/JavaScript/Reference/Global_Objects/EvalError
+---
+<div>{{JSRef}}</div>
+
+<p>O Objeto <strong><code>EvalError</code></strong> indica um erro em relação a função global {{jsxref("Global_Objects/eval", "eval()")}}. Esta exceção não é mais lançada pelo JavaScript, no entanto, o objeto <code>EvalError</code> ainda permanece compatível.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>new EvalError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>message</code></dt>
+ <dd>Opcional. Descrição do erro legível para humanos</dd>
+ <dt><code>fileName</code> {{non-standard_inline}}</dt>
+ <dd>Opcional. O nome do arquivo que contém o código que causa a exceção</dd>
+ <dt><code>lineNumber</code> {{non-standard_inline}}</dt>
+ <dd>Opcional. O número da linha do código que causa a exceção</dd>
+</dl>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("EvalError.prototype")}}</dt>
+ <dd>Permite a adição de propriedades para um objeto <code>EvalError</code>.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<p>O global <code>EvalError</code> não contém métodos próprios, no entando, ele irá herdar alguns métodos através da cadeia de protótipos.</p>
+
+<h2 id="Instâncias_do_EvalError"><code>Instâncias do EvalError</code></h2>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Properties')}}</div>
+
+<h3 id="Métodos_2">Métodos</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/EvalError/prototype', 'Methods')}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p><code>EvalError</code> não é usado na especificação ECMAScript e deste modo não será lançado pelo tempo de execução. No entando, o objeto em si permanece para compatibilidade com versões anteriores da especificação.</p>
+
+<h3 id="Criando_um_EvalError">Criando um <code>EvalError</code></h3>
+
+<pre class="brush: js">try {
+  throw new EvalError('Hello', 'someFile.js', 10);
+} catch (e) {
+  console.log(e instanceof EvalError); // true
+  console.log(e.message);              // "Hello"
+  console.log(e.name);                 // "EvalError"
+  console.log(e.fileName);             // "someFile.js"
+  console.log(e.lineNumber);           // 10
+  console.log(e.columnNumber);         // 0
+  console.log(e.stack);                // "@Scratchpad/2:2:9\n"
+}
+</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('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.6.1', 'EvalError')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Não utilizada na especificação. Presente para compatibilidade com outras versões.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Não utilizada na especificação. Presente para compatibilidade com outras versões.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-evalerror', 'EvalError')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_Navegadores">Compatibilidade dos Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Móvel</th>
+   <th>Opera Móvel</th>
+   <th>Safari Móvel</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Error")}}</li>
+ <li>{{jsxref("EvalError.prototype")}}</li>
+ <li>{{jsxref("Global_Objects/eval", "eval()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/float32array/index.html b/files/pt-br/web/javascript/reference/global_objects/float32array/index.html
new file mode 100644
index 0000000000..9bd9a6a33d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/float32array/index.html
@@ -0,0 +1,200 @@
+---
+title: Float32Array
+slug: Web/JavaScript/Reference/Global_Objects/Float32Array
+translation_of: Web/JavaScript/Reference/Global_Objects/Float32Array
+---
+<div>{{JSRef}}</div>
+
+<p>A array tipada <strong><code>Float32Array</code></strong> representa uma array de 32-bits contendo floats (correspondendo ao tipo de dados <code>float</code> em C) na ordem dos bytes da plataforma. Se o controle sobre a ordem dos bytes for precisa, use {{jsxref("DataView")}}. Os conteúdos iniciam em <code>0</code>. Uma vez estabelecido, você pode referenciar os elementos na array usando os métodos do objeto ou usando a síntaxe padrão das arrays (Isto é, usando colchetes)</p>
+
+<h2 id="Síntaxe">Síntaxe</h2>
+
+<pre class="syntaxbox">new Float32Array(); // novo no ES2017
+new Float32Array(length);
+new Float32Array(typedArray);
+new Float32Array(object);
+new Float32Array(buffer [, byteOffset [, length]]);</pre>
+
+<p>Para mais informações sobre a síntaxe de construção e os parâmetros, veja <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float32Array.BYTES_PER_ELEMENT")}}</dt>
+ <dd>Retorna um número valor do tamanho do elemento. <code>4</code> no caso de uma <code>Float32Array</code>.</dd>
+ <dt>Float32Array.length</dt>
+ <dd>Método estático cujo o valor é <code>0</code>. Para o tamanho atual (número de elementos), veja {{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}}.</dd>
+ <dt>{{jsxref("TypedArray.name", "Float32Array.name")}}</dt>
+ <dd>Retorna o valor em string do nome do constructor. No caso de <code>Float32Array</code> é  "Float32Array".</dd>
+ <dt>{{jsxref("TypedArray.prototype", "Float32Array.prototype")}}</dt>
+ <dd>Prototype para os objetos <em>TypedArray</em>.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.from", "Float32Array.from()")}}</dt>
+ <dd>Cria uma nova <code>Float32Array</code> de um array-like ou um objeto iterável. Veja também {{jsxref("Array.from()")}}.</dd>
+ <dt>{{jsxref("TypedArray.of", "Float32Array.of()")}}</dt>
+ <dd>Cria uma nova <code>Float32Array</code> with um número variável de argumentos. Veja também {{jsxref("Array.of()")}}.</dd>
+</dl>
+
+<h2 id="Float32Array_prototype"><code>Float32Array</code> prototype</h2>
+
+<p>Todos os objetos <code>Float32Array</code> herdam de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<dl>
+ <dt><code>Float32Array.prototype.constructor</code></dt>
+ <dd>Retorna a função cujo criou o protótipo da instância. Este é o construtor padrão da Array <code>Float32Array</code>.</dd>
+ <dt>{{jsxref("TypedArray.prototype.buffer", "Float32Array.prototype.buffer")}} {{readonlyInline}}</dt>
+ <dd>Retorna os {{jsxref("ArrayBuffer")}} referenciado pela Array <code>Float32Array</code> fixada na hora de sua construção e é <strong>somente leitura</strong>.</dd>
+ <dt>{{jsxref("TypedArray.prototype.byteLength", "Float32Array.prototype.byteLength")}} {{readonlyInline}}</dt>
+ <dd>Retorna o tamanho (em bytes) da Array <code>Float32Array</code> do começo de seu {{jsxref("ArrayBuffer")}}. Fixado na hora de sua construção e é <strong>somente leitura</strong>.</dd>
+ <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float32Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
+ <dd>Retorna o deslocamento (em bytes) da Array <code>Float32Array</code> do começo de seu {{jsxref("ArrayBuffer")}}. Fixado na hora de sua construção e é <strong>somente leitura</strong>.</dd>
+ <dt>{{jsxref("TypedArray.prototype.length", "Float32Array.prototype.length")}} {{readonlyInline}}</dt>
+ <dd>Retorna o número de elementos na Array <code>Float32Array</code> do começo de seu {{jsxref("ArrayBuffer")}}. Fixado na hora de sua construção e é <strong>somente leitura</strong>.</dd>
+</dl>
+
+<h3 id="Métodos_2">Métodos</h3>
+
+<dl>
+ <dt>{{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}</dt>
+ <dd>Copia a sequência dos elementos dentro da Array. Veja também {{jsxref("Array.prototype.copyWithin()")}}.</dd>
+ <dt>{{jsxref("TypedArray.entries", "Float32Array.prototype.entries()")}}</dt>
+ <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os pares chave/valor para cada índex na array. Veja também {{jsxref("Array.prototype.entries()")}}.</dd>
+ <dt>{{jsxref("TypedArray.every", "Float32Array.prototype.every()")}}</dt>
+ <dd>Testa quando todos os elementos na array passam no teste proveniente de uma função. Veja também {{jsxref("Array.prototype.every()")}}.</dd>
+ <dt>{{jsxref("TypedArray.fill", "Float32Array.prototype.fill()")}}</dt>
+ <dd>Preenche todos os elementos de uma array do índex inicial ao índex final com um valor estático. Veja também {{jsxref("Array.prototype.fill()")}}.</dd>
+ <dt>{{jsxref("TypedArray.filter", "Float32Array.prototype.filter()")}}</dt>
+ <dd>Cria uma nova array com todos os elementos dessa array para a função de filtragem que retornar <code>true</code>. Veja também {{jsxref("Array.prototype.filter()")}}.</dd>
+ <dt>{{jsxref("TypedArray.find", "Float32Array.prototype.find()")}}</dt>
+ <dd>Retorna o valor na array encontrado, se um elemento na array satizfaz o teste proveniente de uma função de teste ou <code>undefined</code> se não for encontrado. Veja também {{jsxref("Array.prototype.find()")}}.</dd>
+ <dt>{{jsxref("TypedArray.findIndex", "Float32Array.prototype.findIndex()")}}</dt>
+ <dd>Retorna o index encontrado na array,  se um elemento na array satizfaz o teste proveniente de uma função de teste ou -1 se não for encontrado. Veja também {{jsxref("Array.prototype.findIndex()")}}.</dd>
+ <dt>{{jsxref("TypedArray.forEach", "Float32Array.prototype.forEach()")}}</dt>
+ <dd>Chama uma função para cada elemento na array. Veja também {{jsxref("Array.prototype.forEach()")}}.</dd>
+ <dt>{{jsxref("TypedArray.includes", "Float32Array.prototype.includes()")}} {{experimental_inline}}</dt>
+ <dd>Determina quando a array tipada inclui um certo elemento, retornando <code>true</code> ou <code>false</code> como apropriado. Veja também {{jsxref("Array.prototype.includes()")}}.</dd>
+ <dt>{{jsxref("TypedArray.indexOf", "Float32Array.prototype.indexOf()")}}</dt>
+ <dd>Retorna o primeiro (menor) index de um elemento dentro de uma array igual ao valor expecificado, ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.indexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.join", "Float32Array.prototype.join()")}}</dt>
+ <dd>Junta todos os elementos de uma array em uma string. Veja também {{jsxref("Array.prototype.join()")}}.</dd>
+ <dt>{{jsxref("TypedArray.keys", "Float32Array.prototype.keys()")}}</dt>
+ <dd>Retorna um novo <code>Array Iterator</code> cujo contem as chaves para cada index na array. Veja também {{jsxref("Array.prototype.keys()")}}.</dd>
+ <dt>{{jsxref("TypedArray.lastIndexOf", "Float32Array.prototype.lastIndexOf()")}}</dt>
+ <dd>Retorna o último (maior) índex de um elemento dentro da array igual ao valor especificado, ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.map", "Float32Array.prototype.map()")}}</dt>
+ <dd>Cria uma nova array com os resultados da função chamada em cada elemento nesta array. Veja também {{jsxref("Array.prototype.map()")}}.</dd>
+ <dt>{{jsxref("TypedArray.move", "Float32Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
+ <dd>Versão antiga não padrão de {{jsxref("TypedArray.copyWithin", "Float32Array.prototype.copyWithin()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reduce", "Float32Array.prototype.reduce()")}}</dt>
+ <dd>Aplica uma função contra um acumulador e cada valor na array (da esquerda para a direita) com o intuito de reduzí-la a um único valor. Veja também {{jsxref("Array.prototype.reduce()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reduceRight", "Float32Array.prototype.reduceRight()")}}</dt>
+ <dd>Aplica uma função contra um acumulador e cada valor na array (da direita para a esquerda) como o intuito de reduzí-la a um único valor. See also {{jsxref("Array.prototype.reduceRight()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reverse", "Float32Array.prototype.reverse()")}}</dt>
+ <dd>Reverte a ordem se todos os elementos em uma array - o primeiro se torna o último, e o último de torna o primeiro. Veja também {{jsxref("Array.prototype.reverse()")}}.</dd>
+ <dt>{{jsxref("TypedArray.set", "Float32Array.prototype.set()")}}</dt>
+ <dd>Armazena múltiplos valores na array tipada, lendo os valores de entrada de uma array especificada.</dd>
+ <dt>{{jsxref("TypedArray.slice", "Float32Array.prototype.slice()")}}</dt>
+ <dd>Extrai uma seção de uma array e retorna uma nova array. Veja também {{jsxref("Array.prototype.slice()")}}.</dd>
+ <dt>{{jsxref("TypedArray.some", "Float32Array.prototype.some()")}}</dt>
+ <dd>Retorna true se pelo menos um elemento nesta array satisfazer a função de teste proveniente de uma função de teste. Veja também {{jsxref("Array.prototype.some()")}}.</dd>
+ <dt>{{jsxref("TypedArray.sort", "Float32Array.prototype.sort()")}}</dt>
+ <dd>Classifica os elementos de uma array no lugar e retorna a array. Veja também {{jsxref("Array.prototype.sort()")}}.</dd>
+ <dt>{{jsxref("TypedArray.subarray", "Float32Array.prototype.subarray()")}}</dt>
+ <dd>Retorna uma nova Array <code>Float32Array</code> a partir de um ponto inicial e um fim pelo índex do elemento.</dd>
+ <dt>{{jsxref("TypedArray.values", "Float32Array.prototype.values()")}}</dt>
+ <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os valores para cada índex na Array. Veja também {{jsxref("Array.prototype.values()")}}.</dd>
+ <dt>{{jsxref("TypedArray.toLocaleString", "Float32Array.prototype.toLocaleString()")}}</dt>
+ <dd>Retorna uma string localizada representando a array e seus elementos. Veja também {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.toString", "Float32Array.prototype.toString()")}}</dt>
+ <dd>Retorna uma string representando a array e seus elementos. Veja também {{jsxref("Array.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.@@iterator", "Float32Array.prototype[@@iterator]()")}}</dt>
+ <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os valores para cada índex na Array.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Diferentes modos de criar uma Array <code>Float32Array</code>:</p>
+
+<pre class="brush: js">// Pelo seu tamanho
+var float32 = new Float32Array(2);
+float32[0] = 42;
+console.log(float32[0]); // 42
+console.log(float32.length); // 2
+console.log(float32.BYTES_PER_ELEMENT); // 4
+
+// Por uma array
+var arr = new Float32Array([21,31]);
+console.log(arr[1]); // 31
+
+// Por uma outra TypedArray
+var x = new Float32Array([21, 31]);
+var y = new Float32Array(x);
+console.log(y[0]); // 21
+
+// Por um ArrayBuffer
+var buffer = new ArrayBuffer(16);
+var z = new Float32Array(buffer, 0, 4);
+
+// Por um iterável
+var iterable = function*(){ yield* [1,2,3]; }();
+var float32 = new Float32Array(iterable);
+// Float32Array[1, 2, 3]
+</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">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('Typed Array')}}</td>
+   <td>{{Spec2('Typed Array')}}</td>
+   <td>Suplantada pelo ECMAScript 2015.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#table-49', 'TypedArray constructors')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial no padrão ECMA. Especificado que o <code>new</code> é requerido.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>O ECMAScript 7 mudou o construtor da Array <code>Array32Float</code> para o uso da operação <code>ToIndex</code> e ajudar nos construtores sem argumentos.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+<div class="hidden">A tabela de compatibilidade nesta pagina é gerada por dados estruturados. Se você quiser contribuir com os dados, por favor veja The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande um pull request.</div>
+
+<p>{{Compat("javascript.builtins.Float32Array")}}</p>
+
+<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
+
+<p>Começando com o ECMAScript 2015, construtores da Array <code>Float32Array</code> requerem o uso do operador {{jsxref("Operators/new", "new")}}. Chamando o construtor da Array <code>Float32Array</code> como uma função, sem o <code>new</code>, irá gerar um erro {{jsxref("TypeError")}} de agora em diante.</p>
+
+<pre class="brush: js example-bad">var dv = Float32Array([1, 2, 3]);
+
+// TypeError: chamando o construtor da função interna Float32Array
+// sem o new é proibido</pre>
+
+<pre class="brush: js example-good">var dv = new Float32Array([1, 2, 3]);</pre>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript arrays tipadas</a></li>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li>{{jsxref("DataView")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/float64array/index.html b/files/pt-br/web/javascript/reference/global_objects/float64array/index.html
new file mode 100644
index 0000000000..63a7ae3f33
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/float64array/index.html
@@ -0,0 +1,160 @@
+---
+title: Float64Array
+slug: Web/JavaScript/Reference/Global_Objects/Float64Array
+translation_of: Web/JavaScript/Reference/Global_Objects/Float64Array
+---
+<div>{{JSRef}}</div>
+
+<p>The <strong><code>Float64Array</code></strong> typed array represents an array of 64-bit floating point numbers (corresponding to the C <code>double</code> data type) in the platform byte order. If control over byte order is needed, use {{jsxref("DataView")}} instead. The contents are initialized to <code>0</code>. Once established, you can reference elements in the array using the object's methods, or using standard array index syntax (that is, using bracket notation).</p>
+
+<h2 id="Constructor">Constructor</h2>
+
+<dl>
+ <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array/Float64Array"><code>Float64Array()</code></a></dt>
+ <dd>Cria um novo objeto <code>Float64Array</code></dd>
+</dl>
+
+<h2 id="Static_properties">Static properties</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Float64Array.BYTES_PER_ELEMENT")}}</dt>
+ <dd>Retorna um valor numerico de tamanho . <code>8</code> no caso de um <code>Float64Array</code>.</dd>
+ <dt>{{jsxref("TypedArray.name", "Float64Array.name")}}</dt>
+ <dd>Retorna uma string com o nome do contructor. no caso de<code>Float64Array</code> type: "Float64Array".</dd>
+</dl>
+
+<h2 id="Static_methods">Static methods</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.from", "Float64Array.from()")}}</dt>
+ <dd>Cria um novo <code>Float64Array</code> a partir de um array-like ou um objeto iteravel . tambem como {{jsxref("Array.from()")}}.</dd>
+ <dt>{{jsxref("TypedArray.of", "Float64Array.of()")}}</dt>
+ <dd>Cria um novo <code>Float64Array</code> com um numero variado de argumentos. tambem como {{jsxref("Array.of()")}}.</dd>
+</dl>
+
+<h2 id="Instance_properties">Instance properties</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.prototype.buffer", "Float64Array.prototype.buffer")}}</dt>
+ <dd>Returns the {{jsxref("ArrayBuffer")}} referenced by the <code>Float64Array</code> Fixed at construction time and thus <strong>read only</strong>.</dd>
+ <dt>{{jsxref("TypedArray.prototype.byteLength", "Float64Array.prototype.byteLength")}}</dt>
+ <dd>Returns the length (in bytes) of the <code>Float64Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd>
+ <dt>{{jsxref("TypedArray.prototype.byteOffset", "Float64Array.prototype.byteOffset")}}</dt>
+ <dd>Returns the offset (in bytes) of the <code>Float64Array</code> from the start of its {{jsxref("ArrayBuffer")}}. Fixed at construction time and thus <strong>read only.</strong></dd>
+ <dt>{{jsxref("TypedArray.prototype.length", "Float64Array.prototype.length")}}</dt>
+ <dd>Returns the number of elements hold in the <code>Float64Array</code>. Fixed at construction time and thus <strong>read only.</strong></dd>
+</dl>
+
+<h2 id="Instance_methods">Instance methods</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.copyWithin", "Float64Array.prototype.copyWithin()")}}</dt>
+ <dd>Copies a sequence of array elements within the array. See also {{jsxref("Array.prototype.copyWithin()")}}.</dd>
+ <dt>{{jsxref("TypedArray.entries", "Float64Array.prototype.entries()")}}</dt>
+ <dd>Returns a new <code>Array Iterator</code> object that contains the key/value pairs for each index in the array. See also {{jsxref("Array.prototype.entries()")}}.</dd>
+ <dt>{{jsxref("TypedArray.every", "Float64Array.prototype.every()")}}</dt>
+ <dd>Tests whether all elements in the array pass the test provided by a function. See also {{jsxref("Array.prototype.every()")}}.</dd>
+ <dt>{{jsxref("TypedArray.fill", "Float64Array.prototype.fill()")}}</dt>
+ <dd>Fills all the elements of an array from a start index to an end index with a static value. See also {{jsxref("Array.prototype.fill()")}}.</dd>
+ <dt>{{jsxref("TypedArray.filter", "Float64Array.prototype.filter()")}}</dt>
+ <dd>Creates a new array with all of the elements of this array for which the provided filtering function returns true. See also {{jsxref("Array.prototype.filter()")}}.</dd>
+ <dt>{{jsxref("TypedArray.find", "Float64Array.prototype.find()")}}</dt>
+ <dd>Returns the found value in the array, if an element in the array satisfies the provided testing function or <code>undefined</code> if not found. See also {{jsxref("Array.prototype.find()")}}.</dd>
+ <dt>{{jsxref("TypedArray.findIndex", "Float64Array.prototype.findIndex()")}}</dt>
+ <dd>Returns the found index in the array, if an element in the array satisfies the provided testing function or -1 if not found. See also {{jsxref("Array.prototype.findIndex()")}}.</dd>
+ <dt>{{jsxref("TypedArray.forEach", "Float64Array.prototype.forEach()")}}</dt>
+ <dd>Calls a function for each element in the array. See also {{jsxref("Array.prototype.forEach()")}}.</dd>
+ <dt>{{jsxref("TypedArray.includes", "Float64Array.prototype.includes()")}}</dt>
+ <dd>Determines whether a typed array includes a certain element, returning <code>true</code> or <code>false</code> as appropriate. See also {{jsxref("Array.prototype.includes()")}}.</dd>
+ <dt>{{jsxref("TypedArray.indexOf", "Float64Array.prototype.indexOf()")}}</dt>
+ <dd>Returns the first (least) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.indexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.join", "Float64Array.prototype.join()")}}</dt>
+ <dd>Joins all elements of an array into a string. See also {{jsxref("Array.prototype.join()")}}.</dd>
+ <dt>{{jsxref("TypedArray.keys", "Float64Array.prototype.keys()")}}</dt>
+ <dd>Returns a new <code>Array Iterator</code> that contains the keys for each index in the array. See also {{jsxref("Array.prototype.keys()")}}.</dd>
+ <dt>{{jsxref("TypedArray.lastIndexOf", "Float64Array.prototype.lastIndexOf()")}}</dt>
+ <dd>Returns the last (greatest) index of an element within the array equal to the specified value, or -1 if none is found. See also {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.map", "Float64Array.prototype.map()")}}</dt>
+ <dd>Creates a new array with the results of calling a provided function on every element in this array. See also {{jsxref("Array.prototype.map()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reduce", "Float64Array.prototype.reduce()")}}</dt>
+ <dd>Apply a function against an accumulator and each value of the array (from left-to-right) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduce()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reduceRight", "Float64Array.prototype.reduceRight()")}}</dt>
+ <dd>Apply a function against an accumulator and each value of the array (from right-to-left) as to reduce it to a single value. See also {{jsxref("Array.prototype.reduceRight()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reverse", "Float64Array.prototype.reverse()")}}</dt>
+ <dd>Reverses the order of the elements of an array — the first becomes the last, and the last becomes the first. See also {{jsxref("Array.prototype.reverse()")}}.</dd>
+ <dt>{{jsxref("TypedArray.set", "Float64Array.prototype.set()")}}</dt>
+ <dd>Stores multiple values in the typed array, reading input values from a specified array.</dd>
+ <dt>{{jsxref("TypedArray.slice", "Float64Array.prototype.slice()")}}</dt>
+ <dd>Extracts a section of an array and returns a new array. See also {{jsxref("Array.prototype.slice()")}}.</dd>
+ <dt>{{jsxref("TypedArray.some", "Float64Array.prototype.some()")}}</dt>
+ <dd>Returns true if at least one element in this array satisfies the provided testing function. See also {{jsxref("Array.prototype.some()")}}.</dd>
+ <dt>{{jsxref("TypedArray.sort", "Float64Array.prototype.sort()")}}</dt>
+ <dd>Sorts the elements of an array in place and returns the array. See also {{jsxref("Array.prototype.sort()")}}.</dd>
+ <dt>{{jsxref("TypedArray.subarray", "Float64Array.prototype.subarray()")}}</dt>
+ <dd>Returns a new <code>Float64Array</code> from the given start and end element index.</dd>
+ <dt>{{jsxref("TypedArray.values", "Float64Array.prototype.values()")}}</dt>
+ <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array. See also {{jsxref("Array.prototype.values()")}}.</dd>
+ <dt>{{jsxref("TypedArray.toLocaleString", "Float64Array.prototype.toLocaleString()")}}</dt>
+ <dd>Returns a localized string representing the array and its elements. See also {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.toString", "Float64Array.prototype.toString()")}}</dt>
+ <dd>Returns a string representing the array and its elements. See also {{jsxref("Array.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.@@iterator", "Float64Array.prototype[@@iterator]()")}}</dt>
+ <dd>Returns a new <code>Array Iterator</code> object that contains the values for each index in the array.</dd>
+</dl>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Different_ways_to_create_a_Float64Array">Different ways to create a <code>Float64Array</code></h3>
+
+<pre class="brush: js notranslate">// From a length
+var float64 = new Float64Array(2);
+float64[0] = 42;
+console.log(float64[0]); // 42
+console.log(float64.length); // 2
+console.log(float64.BYTES_PER_ELEMENT); // 8
+
+// From an array
+var arr = new Float64Array([21,31]);
+console.log(arr[1]); // 31
+
+// From another TypedArray
+var x = new Float64Array([21, 31]);
+var y = new Float64Array(x);
+console.log(y[0]); // 21
+
+// From an ArrayBuffer
+var buffer = new ArrayBuffer(32);
+var z = new Float64Array(buffer, 0, 4);
+
+// From an iterable
+var iterable = function*(){ yield* [1,2,3]; }();
+var float64 = new Float64Array(iterable);
+// Float64Array[1, 2, 3]
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Float64Array")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li>{{jsxref("DataView")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/apply/index.html b/files/pt-br/web/javascript/reference/global_objects/function/apply/index.html
new file mode 100644
index 0000000000..a51af3db97
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/apply/index.html
@@ -0,0 +1,249 @@
+---
+title: Function.prototype.apply()
+slug: Web/JavaScript/Reference/Global_Objects/Function/apply
+tags:
+  - Funções
+  - JavaScript
+  - Métodos
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/apply
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>apply()</strong></code> chama uma função com um dado valor <code>this </code>e <code>arguments </code>providos como uma array (ou um objeto parecido com um array).</p>
+
+<div class="note">
+<p><strong>Nota:</strong> A sintaxe desta função é quase idêntica a essa da {{jsxref("Function.call", "call()")}}, a diferença é que <code>call()</code> aceita uma <strong> lista de </strong><strong style="background-color: rgba(231, 228, 157, 0.247059); color: rgba(0, 0, 0, 0.65098); font-style: italic;">argumentos</strong>, enquanto <code>apply()</code> aceita um<strong> array de argumentos</strong>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>fun</var>.apply(<var>thisArg, </var>[<var>argsArray</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>thisArg</code></dt>
+ <dd>
+ <p>O valor de <code>this</code> é fornecido para a chamada de <em>fun. </em>Note que isso talvez não seja o valor real visto pelo método:  se um método é uma função em código {{jsxref("Functions/Strict_mode", "non-strict mode", "", 1)}} , {{jsxref("null")}} e {{jsxref("undefined")}} serão substituidos com o objeto global, e os valores primitivos serão embalados.</p>
+ </dd>
+ <dt><code>argsArray</code></dt>
+ <dd>Um objeto parecido com um array (array-like), especificando os argumentos com os quais <em>fun </em>deve ser chamado, ou {{jsxref("null")}} ou {{jsxref("undefined")}} se não houverem argumentos que possam ser passados para a função. Começando com ECMAScript5 esses argumentos podem ser um objeto genérico array-like ao invés de um array. Veja abaixo a informação de {{anch("Browser_compatibility", "compatibilidade de browsers")}}.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Você pode atribuir um objeto <code>this</code><em> </em>diferente quando chamar uma função existente. <code>this</code><em> </em>refere-se ao objeto atual, o objeto da chamada. Com <code>apply</code><em>, </em>você pode escrever um método apenas uma vez e então herdá-lo em outro objeto, sem ter que reescrever o método para o novo objeto.</p>
+
+<p><code>apply </code>é muito parecido com {{jsxref("Function.call", "call()")}}, exceto pelo tipo de argumentos que ele suporta. Você pode usar um array de argumentos em vez de conjunto de parâmetros nomeados. Com <code>apply, </code>você pode usar um array literal, por exemplo, <code><em>fun</em>.apply(this, ['comer', 'bananas'])</code>, ou um objeto {{jsxref("Array")}}, por exemplo f<code><em>un</em>.apply(this, new Array('comer', 'bananas')).</code></p>
+
+<p>Você pode também usar {{jsxref("Functions/arguments", "arguments")}} para o parâmetro <code>argsArray.</code> <code>arguments </code>é uma variável local de uma função.  Ele pode ser utilizado para todos os argumentos não especificados do objeto chamado. Assim, você não tem que saber os argumentos do objeto chamado quando você usa o método <code>apply</code>. Você pode usar <code>arguments </code>para passar todos os argumentos para o objeto da chamada. O objeto chamado fica então responsável por manipular os argumentos.</p>
+
+<p>Desde a 5a versão do ECMAScript você pode utilizar qualquer tipo de objeto que é parecido com um array (array-like), então na prática isso significa que ele vai ter uma propriedade <code>length </code>e propriedades inteiras no intervalor (<code>0... length</code>). Como um exemplo, você pode agora usar um {{domxref("NodeList")}} ou um objeto personalizado como <code>{ 'length': 2, '0': 'comer', '1': 'bananas' }</code>.</p>
+
+<p>{{note("Muitos navegadores, incluindo o Chrome 14 e o Internet Explorer 9, ainda não aceitam objetos parecidos com array e irão lançar uma exceção.")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_apply_para_cadeia_de_construtores">Usando <code>apply</code> para cadeia de construtores</h3>
+
+<p>Você pode usar <code>apply </code>para encadear {{jsxref("Operators/new", "construtores", "", 1)}} em um objeto, similar ao Java. No exemplo seguinte nós iremos criar um método de {{jsxref("Global_Objects/Function", "Função")}} global chamado <code>construct, </code>que fará você capaz de usar um objeto parecido com um array com um construtor ao invés de uma lista de argumentos</p>
+
+<pre class="brush: js">Function.prototype.construct = function (aArgs) {
+  var oNew = Object.create(this.prototype);
+  this.apply(oNew, aArgs);
+  return oNew;
+};
+</pre>
+
+<div class="note">
+<p><strong>Note:</strong> O método <code>Object.create()</code>  usado acima é relativamente novo. Para um método alternativo utilizando closures, por favor considere a seguinte alternativa.</p>
+
+<pre class="brush: js">Function.prototype.construct = function(aArgs) {
+  var fConstructor = this, fNewConstr = function() { fConstructor.apply(this, aArgs); };
+  fNewConstr.prototype = fConstructor.prototype;
+  return new fNewConstr();
+};</pre>
+</div>
+
+<p>Exemplo de uso:</p>
+
+<pre class="brush: js">function MyConstructor() {
+  for (var nProp = 0; nProp &lt; arguments.length; nProp++) {
+    this['property' + nProp] = arguments[nProp];
+  }
+}
+
+var myArray = [4, 'Hello world!', false];
+var myInstance = MyConstructor.construct(myArray);
+
+console.log(myInstance.property1);                // logs 'Hello world!'
+console.log(myInstance instanceof MyConstructor); // logs 'true'
+console.log(myInstance.constructor);              // logs 'MyConstructor'
+</pre>
+
+<div class="note">
+<p><strong>Nota:</strong>  Este método não nativo <code>Function.construct </code>não irá funcionar com alguns construtores nativos (como {{jsxref("Date")}}, por exemplo). Nestes casos você tem que usar o método {{jsxref("Function.prototype.bind")}} (por exemplo, imagine ter um array como o seguinte, para ser usado com o construtor {{jsxref("Global_Objects/Date", "Date")}}: <code>[2012, 11, 4]</code>; Neste caso você tem que escrever algom como: <code>new (Function.prototype.bind.apply(Date, [null].concat([2012, 11, 4])))() - </code>de qualquer maneira essa não é a melhor forma de fazer as coisas e provavelmente não deve ser utilizado em qualquer ambiente de produção</p>
+</div>
+
+<h3 id="Usando_apply_e_funções_embutidas">Usando <code>apply</code> e funções embutidas</h3>
+
+<p>A forma inteligente com que <code>apply</code> é utilizado permite à você usar funções nativas que de outra forma provavelmente teriam que ser escritas iterando sobre um array de valores. Aqui, como exemplo, iremos utilizar <code>Math.max</code>/<code>Math.min</code> para achar o valor máximo/mínimo value em um array.</p>
+
+<pre class="brush: js">/* número min/max em um array */
+var numbers = [5, 6, 2, 3, 7];
+
+/* utilizando Math.min/Math.max apply */
+var max = Math.max.apply(null, numbers); /* Isso está prestes a ser igual a Math.max(numbers[0], ...)
+                                            ou Math.max(5, 6, ...) */
+var min = Math.min.apply(null, numbers);
+
+/* vs. algoritmo simples baseado em loop */
+max = -Infinity, min = +Infinity;
+
+for (var i = 0; i &lt; numbers.length; i++) {
+  if (numbers[i] &gt; max) {
+    max = numbers[i];
+  }
+  if (numbers[i] &lt; min) {
+    min = numbers[i];
+  }
+}
+</pre>
+
+<p>Mas tome cuidado: ao utilizar o <code>apply</code> desta forma, você corre o risco de exceder o limite de argumentos do JavaScript. As consequências de fazer applying em uma função com muitos argumentos (pense em algo como dezenas de centenas de argumentos) varia de acordo com os engines (JavaScriptCore tem um <a class="link-https" href="https://bugs.webkit.org/show_bug.cgi?id=80797">limite de argumentos de 65536</a> hard-coded), visto que o limite (na verdade, até mesmo a natureza de qualquer comportamento de um stack excessivamente grande) não é especificado. Algumas engines irão jogar uma excessão. De uma forma mais incisiva, outras engines irão limitar de forma arbitrária o número de argumentos que poderção ser aplicados à função. (Para ilustrar esse último caso: se uma engine dessas tem um limite de quatro argumentos [obviamente, os limites atuais são significativamente maiores], isso seria como se os argumentos <code>5, 6, 2, 3</code> do exemplo anterior fossem passados ao <code>apply</code>, ao invés do array completo.) Se o valor do seu array puder crescer à casa das dezenas de centenas, use uma estratégia híbrida: aplique suas funções em cada bloco de array por vez:</p>
+
+<pre class="brush: js">function minOfArray(arr) {
+  var min = Infinity;
+  var QUANTUM = 32768;
+
+  for (var i = 0, len = arr.length; i &lt; len; i += QUANTUM) {
+    var submin = Math.min.apply(null, arr.slice(i, Math.min(i + QUANTUM, len)));
+    min = Math.min(submin, min);
+  }
+
+  return min;
+}
+
+var min = minOfArray([5, 6, 2, 3, 7]);
+</pre>
+
+<h3 id="Usando_apply_em_monkey-patching">Usando apply em "monkey-patching"</h3>
+
+<p>Apply pode ser a melhor forma de monkey-patch uma função nativa do Firefox, ou de bibliotecas em JS. Dada uma função <code>someobject.foo</code>, você poderá modificar a função de uma maneira hackeresca, como por exemplo:</p>
+
+<pre class="brush: js">var originalfoo = someobject.foo;
+someobject.foo = function() {
+  // Faça coisas antes de chamar a função
+  console.log(arguments);
+  // Chama a função como se ela estivesse sido chamada normalmente:
+  originalfoo.apply(this, arguments);
+  // Rode as coisas que vem depois, aqui.
+}
+</pre>
+
+<p>Esse método é especialmente útil quando você quer fazer debug de eventos, ou interagir com algo que não tem nenhuma API como os diversos eventos <code>.on([event]...</code> events, por exemplo aqueles utilizáveis no <a href="/en-US/docs/Tools/Page_Inspector#Developer_API">Devtools Inspector</a>).</p>
+
+<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>ECMAScript 3º Edição.</td>
+   <td>Padrão</td>
+   <td>Definição inicial, implementado no JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.4.3', 'Function.prototype.apply')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function.prototype.apply', 'Function.prototype.apply')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>ES 5.1 objetos genéricos parecidos com array como  {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>ES 5.1 objetos genéricos parecidos com array como  {{jsxref("Functions_and_function_scope/arguments", "arguments")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("2.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>Objeto {{jsxref("Functions/arguments", "arguments")}}</li>
+ <li>{{jsxref("Function.prototype.bind()")}}</li>
+ <li>{{jsxref("Function.prototype.call()")}}</li>
+ <li>{{jsxref("Functions", "Funções e escopo de funções", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html b/files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html
new file mode 100644
index 0000000000..6fac474a16
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/arguments/index.html
@@ -0,0 +1,130 @@
+---
+title: Function.arguments
+slug: Web/JavaScript/Reference/Global_Objects/Function/arguments
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>A propriedade <code><strong><em>function</em>.arguments</strong></code> diz respeito a um objeto tipo array (array-like object) correspondente aos argumentos passados para uma função. Use somente a variável {{jsxref("Functions/arguments", "arguments")}} em vez disso.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A sintaxe <code><em>function</em>.arguments</code> está obsoleta. A forma recomendada de acessar o objeto  {{jsxref("Functions/arguments", "arguments")}} disponível dentro das funções, é simplesmente referenciar a variável {{jsxref("Functions/arguments", "arguments")}}.</p>
+
+<p>No caso de recursão, ou seja, uma função f aparecer várias vezes na pilha de chamadas, o valor de <code>f.arguments</code> representa os argumentos correspondentes a invocação mais recente da função.</p>
+
+<p>O valor da propriedade arguments é normalmente nulo (<code>null</code>) se não houver nenhuma invocação pendente da função em andamento (ou seja, a função foi chamada mas ainda não retornou).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">function f(n) { g(n - 1); }
+
+function g(n) {
+  console.log('before: ' + g.arguments[0]);
+  if (n &gt; 0) { f(n); }
+  console.log('after: ' + g.arguments[0]);
+}
+
+f(2);
+
+console.log('returned: ' + g.arguments);
+
+// Output
+
+// before: 1
+// before: 0
+// after: 0
+// after: 1
+// returned: null
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definiçao inicial. Implementado em JavaScript 1.0. Obsoleto em favor de {{jsxref("Functions/arguments", "arguments")}} em ES3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>{{jsxref("Functions/arguments", "arguments")}} object</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>{{jsxref("Functions/arguments", "arguments")}} object</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>{{jsxref("Functions/arguments", "arguments")}} object</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Functions/arguments", "arguments")}} object</li>
+ <li>{{jsxref("Functions", "Functions and function scope", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/arity/index.html b/files/pt-br/web/javascript/reference/global_objects/function/arity/index.html
new file mode 100644
index 0000000000..93e4fb75b5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/arity/index.html
@@ -0,0 +1,78 @@
+---
+title: Function.arity
+slug: Web/JavaScript/Reference/Global_Objects/Function/arity
+tags:
+  - Função
+  - JavaScript
+  - Não implementado
+  - Obsoleto
+  - Propriedade
+translation_of: Archive/Web/JavaScript/Function.arity
+---
+<div>{{JSRef("Global_Objects", "Function")}} {{obsolete_header}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p class="note">A propriedade <code><strong>arity</strong></code> é usada para retornar o número de argumentos esperados por uma função, entretanto, ela não existe mais e foi substituida pela propriedade {{jsxref("Function.prototype.length")}}.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Implementada no JavaScript 1.2. Depreciada no JavaScript 1.4.</p>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function.prototype.length")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/bind/index.html b/files/pt-br/web/javascript/reference/global_objects/function/bind/index.html
new file mode 100644
index 0000000000..10f3ea1b8c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/bind/index.html
@@ -0,0 +1,309 @@
+---
+title: Function.prototype.bind()
+slug: Web/JavaScript/Reference/Global_Objects/Function/bind
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/bind
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>bind()</strong></code> cria uma nova função que, quando chamada, tem sua palavra-chave <code>this</code> definida com o valor fornecido, com uma sequência determinada de argumentos precedendo quaisquer outros que sejam fornecidos <span id="result_box" lang="pt"><span>quando</span> <span>a nova</span> <span>função é chamada</span></span>.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/function-bind.html", "taller")}}</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>function</var>.bind(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre>
+
+<h3 id="Parâmetros"><span class="short_text" id="result_box" lang="es"><span>Parâmetros</span></span></h3>
+
+<dl>
+ <dt><code>thisArg</code></dt>
+ <dd><span id="result_box" lang="pt"><span>O valor a ser</span> <span>passado como </span><span>parâmetro <code>this</code> para</span> <span>a função de destino</span> <span>quando a função</span> <span>vinculada</span> <span>é chamada.</span> <span>O</span> <span>valor é ignorado</span> <span>se a função</span> <span>ligada é</span> <span>construída usando o</span></span> operador {{jsxref("Operators/new", "new")}}.</dd>
+ <dt><code>arg1, arg2, ...</code></dt>
+ <dd><span id="result_box" lang="pt"><span>Argumentos que precedem outros</span></span><span lang="pt"> <span>argumentos fornecidos</span> <span>para a função</span> vinculada <span>ao invocar</span> <span>a função de destino</span><span>.</span></span></dd>
+</dl>
+
+<h3 id="Valor_de_retorno"><span lang="pt"><span>Valor de retorno</span></span></h3>
+
+<p><span lang="pt"><span>Uma cópia da função fornecida com o valor <code>this</code> especificado e argumentos iniciais.</span></span></p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função <code>bind()</code> cria uma nova <strong>função vinculada</strong> (<em>bound function</em>). Uma função vinculada é um <strong>objeto de função exótico</strong> (termo da <strong>ECMAScript 2015</strong>) que encapsula o objeto de função original. Chamar uma função vinculada geralmente resulta na execução de sua <strong>função encapsulada</strong>.</p>
+
+<p>Uma função vinculada tem as seguintes propriedades internas:</p>
+
+<ul>
+ <li><strong>[[BoundTargetFunction]]</strong> - o objeto de função encapsulado;</li>
+ <li><strong>[[BoundThis]]</strong> - o valor que sempre é passado como <code>this</code> quando se chama a função encapsulada;</li>
+ <li><strong>[[BoundArguments]]</strong> - uma lista de valores cujos elementos são usados como os primeiros argumentos para qualquer chamada da função encapsulada;</li>
+ <li><strong>[[Call]]</strong> - executa código associado com este objeto. Invocado através de uma expressão de chamada de função. Os argumentos para o método interno são um valor <code>this</code> e uma lista contendo os argumentos passados para a função por uma expressão de chamada.</li>
+</ul>
+
+<p>Quando a função vinculada é chamada, ela chama seu método interno <strong>[[Call]]</strong> na <strong>[[BoundTargetFunction]],</strong> na forma <code>Call(boundThis, args)</code>, onde <code>boundThis</code> é <strong>[[BoundThis]]</strong> e <code>args</code> é <strong>[[BoundArguments]]</strong> seguido pelos argumentos passados pela chamada de função.</p>
+
+<p>Uma função vinculada também pode ser construída usando-se o operador {{jsxref("Operators/new", "new")}}; ao fazê-lo, o resultado é o mesmo que seria se a função alvo tivesse sido construída. O valor de <code>this</code> fornecido é ignorado, porém os argumentos precedentes são fornecidos à função emulada.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Criando_uma_função_vinculada">Criando uma função vinculada</h3>
+
+<p><span id="result_box" lang="pt"><span>O uso</span> <span>mais simples de</span> <code><span>bind()</span></code> <span class="alt-edited">é fazer com que</span> <span>uma função que</span><span>, independentemente da</span><span> chamada,</span> <span>é chamada com</span> <span>um determinado</span> valor <code><span>this</span></code></span>.<span id="result_box" lang="pt"><span> Um erro comum</span> <span>para </span><span>programadores JavaScript</span> novatos <span>é extrair</span> <span>um método</span> <span>de um objeto e</span></span>, <span id="result_box" lang="pt"><span>em seguida, </span> <span>chamar essa função</span> <span>e esperar que ele</span> <span>use</span> <span>o objeto original</span> <span>como</span> o seu <code><span>this</span></code> <span>(por exemplo,</span> <span>usando</span> <span>esse método</span> <span>num código baseado em</span></span> <em>callback</em><span lang="pt"><span>)</span><span>.</span> <span>Sem</span> <span>a devida atenção</span><span>,</span> <span>no entanto</span><span>,</span> <span>o objeto original</span> <span>é normalmente</span> <span>perdido</span><span>.</span> <span>Criar</span> <span>uma função</span> <span class="alt-edited">vinculada</span> <span>a partir da função</span><span>,</span> <span>usando o objeto</span> <span>original,</span> <span>resolve perfeitamente</span> <span>esse</span> <span>problema:</span></span></p>
+
+<pre class="brush: js">this.x = 9; //this aqui se refere ao objeto global "window" do navegador
+var module = {
+  x: 81,
+  getX: function() { return this.x; }
+};
+
+module.getX(); // 81
+
+var retrieveX = module.getX;
+retrieveX();
+// retorna 9 - a função foi invocada no escopo global
+
+// Criando uma nova função com 'this' vinculada ao módulo
+// Programadores novatos podem confundir a variável x
+// global com a propriedade x do módulo
+var boundGetX = retrieveX.bind(module);
+boundGetX(); // 81
+</pre>
+
+<h3 id="Funções_parcialmente_aplicadas">Funções parcialmente aplicadas</h3>
+
+<p>O próximo uso mais simples de <code>bind()</code> é criar uma função com argumentos iniciais pré-especificados. Esses argumentos (caso existam) acompanham o valor <code>this</code> fornecido e então são inseridos no início dos argumentos passados para a função alvo, seguidos pelos argumentos passados para a função vinculada, sempre que a função vinculada é chamada.</p>
+
+<pre class="brush: js">function list() {
+  return Array.prototype.slice.call(arguments);
+}
+
+var list1 = list(1, 2, 3); // [1, 2, 3]
+
+// Cria uma função com um argumento principal predefinido
+var leadingThirtysevenList = list.bind(null, 37);
+
+var list2 = leadingThirtysevenList();
+// [37]
+
+var list3 = leadingThirtysevenList(1, 2, 3);
+// [37, 1, 2, 3]
+</pre>
+
+<h3 id="Com_setTimeout">Com <code>setTimeout</code></h3>
+
+<p>Por padrão, dentro de {{domxref("window.setTimeout()")}} a palavra-chave <code>this</code> vai ser definida com o objeto {{ domxref("window") }} (ou com o objeto <code>global</code>). Ao trabalhar com métodos de classes que requerem que <code>this</code> se refira à instâncias de classes, você pode vincular <code>this</code> explicitamente à função de <em>callback</em>, de modo a manter a instância.</p>
+
+<pre class="brush: js">function LateBloomer() {
+  this.petalCount = Math.ceil(Math.random() * 12) + 1;
+}
+
+// Declarar bloom depois de um intervalo de 1 segundo
+LateBloomer.prototype.bloom = function() {
+  window.setTimeout(this.declare.bind(this), 1000);
+};
+
+LateBloomer.prototype.declare = function() {
+  console.log('I am a beautiful flower with ' +
+    this.petalCount + ' petals!');
+};
+
+var flower = new LateBloomer();
+flower.bloom();
+// depois de 1 segundo, ativa o método 'declare'</pre>
+
+<h3 id="Funções_vinculadas_usadas_como_construtores">Funções vinculadas usadas como construtores</h3>
+
+<div class="warning">
+<p><strong>Aviso:</strong> Esta seção demonstra capacidades do JavaScript e documenta alguns casos de borda do método <code>bind()</code>. Os métodos mostrados abaixo não são os melhores jeitos de se fazer as coisas e provavelmente não deveriam ser usados em nenhum ambiente produtivo.</p>
+</div>
+
+<p>Funções vinculadas são automaticamente adequadas para uso com o operador {{jsxref("Operators/new", "new")}} para construir novas instâncias criadas pela função alvo. Quando uma função vinculada é usada para construir um valor, o <code>this</code> fornecido é ignorado. Porém, argumentos fornecidos ainda são prefixados à chamada do construtor:</p>
+
+<pre class="brush: js">function Point(x, y) {
+  this.x = x;
+  this.y = y;
+}
+
+Point.prototype.toString = function() {
+  return this.x + ',' + this.y;
+};
+
+var p = new Point(1, 2);
+p.toString(); // '1,2'
+
+// não suportado no polyfill abaixo,
+// funciona bem com o bind nativo:
+
+var YAxisPoint = Point.bind(null, 0/*x*/);
+
+var emptyObj = {};
+var YAxisPoint = Point.bind(emptyObj, 0/*x*/);
+
+var axisPoint = new YAxisPoint(5);
+axisPoint.toString(); // '0,5'
+
+axisPoint instanceof Point; // true
+axisPoint instanceof YAxisPoint; // true
+new Point(17, 42) instanceof YAxisPoint; // true
+</pre>
+
+<p>Note que você não precisa fazer nada de especial para criar uma função vinculada para usar com {{jsxref("Operators/new", "new")}}. O corolário é que você não precisa fazer nada de especial para criar uma função vinculada que será chamada de forma clara, mesmo que você preferisse que a função vinculada fosse somente chamada usando-se {{jsxref("Operators/new", "new")}}.</p>
+
+<pre class="brush: js">// Exemplo pode ser executado diretamente no seu console JavaScript
+// ...continuando o exemplo acima
+
+// Ainda pode ser chamada como uma função normal
+// (apesar de que isso geralmente não é desejado)
+YAxisPoint(13);
+
+emptyObj.x + ',' + emptyObj.y;
+// &gt;  '0,13'
+</pre>
+
+<p>Se você quer suportar o uso de uma função vinculada somente através de {{jsxref("Operators/new", "new")}}, ou somente a chamando, a função alvo deve impor essa restrição.</p>
+
+<h3 id="Criando_atalhos">Criando atalhos</h3>
+
+<p><code>bind()</code> itambém é útil em casos onde você quer criar um atalho para uma função que requer um valor específico de <code>this</code>.</p>
+
+<p>Tome por exemplo {{jsxref("Array.prototype.slice")}}, que você quer usar para converter um objeto <em>array-like</em> em um vetor verdadeiro. Você poderia criar um atalho assim:</p>
+
+<pre class="brush: js">var slice = Array.prototype.slice;
+
+// ...
+
+slice.apply(arguments);
+</pre>
+
+<p>Com <code>bind()</code>, isso pode ser simplificado. No seguinte trecho de código, <code>slice</code> é uma função vinculada à função {{jsxref("Function.prototype.apply()", "apply()")}} de {{jsxref("Function.prototype")}}, com o valor <code>this</code> definido com a função {{jsxref("Array.prototype.slice()", "slice()")}} de {{jsxref("Array.prototype")}}. Isso significa que chamadas adicionais de <code>apply()</code> podem ser eliminadas:</p>
+
+<pre class="brush: js">// mesmo que "slice" no exemplo anterior
+var unboundSlice = Array.prototype.slice;
+var slice = Function.prototype.apply.bind(unboundSlice);
+
+// ...
+
+slice(arguments);
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>A função <code>bind</code> é uma adição à ECMA-262, 5ª. edição; como tal, pode não estar presente em todos os navegadores. Você pode contornar isso parcialmente inserindo o seguinte código no começo de seus <em>scripts</em>, permitindo o uso de muita parte da funcionalidade de <code>bind()</code> em implementações que não a suportam nativamente.</p>
+
+<pre class="brush: js">if (!Function.prototype.bind) {
+  Function.prototype.bind = function(oThis) {
+    if (typeof this !== 'function') {
+      // mais próximo possível da função interna
+      // IsCallable da ECMAScript 5
+      throw new TypeError('Function.prototype.bind - what is trying to be bound is not callable');
+    }
+
+    var aArgs   = Array.prototype.slice.call(arguments, 1),
+        fToBind = this,
+        fNOP    = function() {},
+        fBound  = function() {
+          return fToBind.apply(this instanceof fNOP
+                 ? this
+                 : oThis,
+                 aArgs.concat(Array.prototype.slice.call(arguments)));
+        };
+
+    fNOP.prototype = this.prototype;
+    fBound.prototype = new fNOP();
+
+    return fBound;
+  };
+}
+</pre>
+
+<p>Algumas das muitas diferenças (é bem possível que haja outras, já que esta lista não pretende seriamente ser completa) entre este algoritmo e o algoritmo especificado são:</p>
+
+<ul>
+ <li>Esta implementação parcial depende dos métodos internos {{jsxref("Array.prototype.slice()")}}, {{jsxref("Array.prototype.concat()")}}, {{jsxref("Function.prototype.call()")}} e {{jsxref("Function.prototype.apply()")}} possuírem seus valores originais.</li>
+ <li>Esta implementação parcial cria funções que não tem um {{jsxref("Function.caller", "caller")}} imutável como "mecanismo de defesa" e propriedades <code>arguments</code> que lançam um {{jsxref("Global_Objects/TypeError", "TypeError")}} ao usar <em>get</em>, <em>set</em>, ou ao deletar. (Isto pode ser adicionado se a implementação suporta {{jsxref("Object.defineProperty")}}, ou parcialmente implementado sem um comportamento <em>throw-on-delete</em> se a implementação suporta as extensões {{jsxref("Object.defineGetter", "__defineGetter__")}} e {{jsxref("Object.defineSetter", "__defineSetter__")}})</li>
+ <li>Esta implementação parcial cria funções que tem uma propriedade <code>prototype</code>. (Funções vinculadas apropriadas não a tem.)</li>
+ <li>Esta implementação parcial cria funções vinculadas cuja propriedade {{jsxref("Function.length", "length")}} não cumpre com a regra da ECMA-262: cria funções com comprimento zero, quando uma implementação completa, dependendo do comprimento da função alvo e do número de argumentos pre-especificados, pode retornar um comprimento não-nulo.</li>
+</ul>
+
+<p>Se você escolher utilizar esta implementação parcial, <strong>você não deve confiar em casos onde o comportamento é diferente da ECMA-262, 5ª. edição!</strong> Porém, com algum cuidado (e talvez com modificação adicional para atender necessidades específicas), esta implementação parcial pode ser uma ponte razoável para quando <code>bind()</code> for amplamente implementada de acordo com a especificação.</p>
+
+<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('ES5.1', '#sec-15.3.4.5', 'Function.prototype.bind')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function.prototype.bind', 'Function.prototype.bind')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("7")}}</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("11.60")}}</td>
+   <td>{{CompatSafari("5.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatAndroid("4.0")}}</td>
+   <td>{{CompatChrome("1")}}</td>
+   <td>{{CompatGeckoMobile("2")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOperaMobile("11.5")}}</td>
+   <td>{{CompatSafari("6.0")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function.prototype.apply()")}}</li>
+ <li>{{jsxref("Function.prototype.call()")}}</li>
+ <li>{{jsxref("Functions", "Functions", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/call/index.html b/files/pt-br/web/javascript/reference/global_objects/function/call/index.html
new file mode 100644
index 0000000000..a0356bf585
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/call/index.html
@@ -0,0 +1,194 @@
+---
+title: Function.prototype.call()
+slug: Web/JavaScript/Reference/Global_Objects/Function/call
+tags:
+  - Função
+  - JavaScript
+  - Método(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/call
+---
+<div>{{JSRef("Global_Objects", "Function")}}</div>
+
+<h2 id="Introdução">Introdução</h2>
+
+<p>O método <code><strong>call()</strong></code> invoca uma função com um dado valor <code>this</code>  e argumentos passados individualmente.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> Apesar de a sintaxe desta função ser quase idêntica à de {{jsxref("Function.prototype.apply", "apply()")}}, a principal diferença é que <code>call()</code> aceita uma <strong>lista de argumentos</strong>, enquanto <code>apply()</code> aceita <strong>um único array de argumentos.</strong></p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>fun</var>.call(<var>thisArg</var>[, <var>arg1</var>[, <var>arg2</var>[, ...]]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>thisArg</code></dt>
+ <dd>O valor de  <code>this</code>  proveu a chamada para <em><code>fun</code></em>. Note que <code>this</code> pode não ser o valor atual visto pelo método: se esse método é uma função em {{jsxref("Functions_and_function_scope/Strict_mode", "non-strict mode", "", 1)}} code, {{jsxref("Global_Objects/null", "null")}} e {{jsxref("Global_Objects/undefined", "undefined")}} serão reescritos com o objeto global, e valores primitivos serão encaixados.</dd>
+ <dt><code>arg1, arg2, ...</code></dt>
+ <dd>Argumentos para  o objeto.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Você pode atribuir um objeto <code>this</code> diferente quando executar uma função existente. <code>this</code> refere-se ao objeto atual, o objeto em execução. Com <code>call</code>, você pode escrever um método uma vez e então herdá-lo em outro objeto, sem ter que reescrever o método para o novo objeto.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_Usando_call_para_encadear_construtores_para_um_objeto">Exemplo: Usando <code>call</code> para encadear construtores para um objeto</h3>
+
+<p>Você pode usar <code>call</code> para encadear construtores para um objeto, similar ao  Java. No seguinte exemplo, o construtor do  objeto <code>Product</code> é definido com dois parâmetros, <code>name</code> e <code>price</code>. Outras duas funções <code>Food</code> e <code>Toy</code> executam <code>Product</code> passando <code>this,</code> <code>name</code> e <code>price</code>. O Produto inicializa as propriedades <code>name</code> e <code>price</code>,  ambos definem o <code>category</code>.</p>
+
+<pre class="brush: js">function Product(name, price) {
+  this.name = name;
+  this.price = price;
+
+  if (price &lt; 0) {
+    throw RangeError('Cannot create product ' +
+                      this.name + ' with a negative price');
+  }
+
+  return this;
+}
+
+function Food(name, price) {
+  Product.call(this, name, price);
+  this.category = 'food';
+}
+
+Food.prototype = Object.create(Product.prototype);
+
+function Toy(name, price) {
+  Product.call(this, name, price);
+  this.category = 'toy';
+}
+
+Toy.prototype = Object.create(Product.prototype);
+
+var cheese = new Food('feta', 5);
+var fun = new Toy('robot', 40);
+</pre>
+
+<h3 id="Exemplo_Usando_o_call_para_chamar_funções_anônimas">Exemplo: Usando o <code>call</code> para chamar funções anônimas</h3>
+
+<p>Neste exemplo, criamos uma função anônima que usa o <code>call</code> para executá-lo em todos os objetos em um array(vetor). O principal propósito da função anônima aqui é adicionar uma função print para todo o objeto, que está disponível para imprimir o índice correto do objeto no array. Não foi necessário passar o valor do objeto como <code>this</code> , mas isso foi feito apenas para explicação.</p>
+
+<pre class="brush: js">var animais = [
+  { especie: 'Lion', nome: 'King' },
+  { especie: 'Whale', nome: 'Fail' }
+];
+
+for (var i = 0; i &lt; animais.length; i++) {
+  (function(i) {
+    this.print = function() {
+      console.log('#' + i + ' ' + this.especie
+                  + ': ' + this.nome);
+    }
+    this.print();
+  }).call(animais[i], i);
+}
+</pre>
+
+<h3 id="Usando_call_para_chamar_a_função_e_especificar_o_contexto_de_'this'">Usando <code>call</code> para chamar a função e especificar o contexto de 'this'</h3>
+
+<p>No exemplo abaixo, quando vamos chamar a apresentação, o valor de this será associado ao objeto i.<br>
+  </p>
+
+<pre><code>function apresentacao() {
+  var resposta = [this.pessoa, 'é um excelente', this.funcao].join(' ');
+  console.log(resposta);
+}
+
+var i = {
+  pessoa: 'Douglas Crockford', funcao: 'Desenvolvedor Javascript'
+};
+
+apresentacao.call(i); // Douglas Crockford é um excelente Desenvolvedor Javascript</code></pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.3.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.4.4', 'Function.prototype.call')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function.prototype.call', 'Function.prototype.call')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function.prototype.bind()")}}</li>
+ <li>{{jsxref("Function.prototype.apply()")}}</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introdução à JavaScript Orientado à Objetos</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/caller/index.html b/files/pt-br/web/javascript/reference/global_objects/function/caller/index.html
new file mode 100644
index 0000000000..c380d89d7f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/caller/index.html
@@ -0,0 +1,129 @@
+---
+title: Function.caller
+slug: Web/JavaScript/Reference/Global_Objects/Function/caller
+tags:
+  - Função
+  - JavaScript
+  - Non-standard
+  - Propriedades
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/caller
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>A propriedade <code><strong><em>function</em>.caller</strong></code> retorna a função que invocou a função especificada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se a função <code>f</code> foi invocada pelo codigo mais alto nível, o valor de <code>f.caller</code> é {{jsxref("null")}}, caso contrario, o valor será a função a qual invocou <code>f</code>.</p>
+
+<p>Esta propriedade substitui a propriedade obsoleta {{jsxref("Functions/arguments/caller", "arguments.caller")}} do objeto {{jsxref("Functions/arguments", "arguments")}}.</p>
+
+<p>A propriedade especial <code>__caller__</code>, a qual retornou o objeto de ativação do chamador, permitindo assin reconstruir o stack, foi removido por motivo de segurança.</p>
+
+<h3 id="Notas">Notas</h3>
+
+<p>Note que no caso de recurção, você não pode reconstruir o stack de chamadas usando esta propriedade. Considere:</p>
+
+<pre class="brush: js">function f(n) { g(n - 1); }
+function g(n) { if (n &gt; 0) { f(n); } else { stop(); } }
+f(2);
+</pre>
+
+<p>No momento em que <code>stop()</code> é chamado o stack será:</p>
+
+<pre class="brush: js">f(2) -&gt; g(1) -&gt; f(1) -&gt; g(0) -&gt; stop()
+</pre>
+
+<p>O seguinte é true:</p>
+
+<pre class="brush: js">stop.caller === g &amp;&amp; f.caller === g &amp;&amp; g.caller === f
+</pre>
+
+<p>então se você tentou recuperar o stack trace na função <code>stop()</code> assim:</p>
+
+<pre class="brush: js">var f = stop;
+var stack = 'Stack trace:';
+while (f) {
+  stack += '\n' + f.name;
+  f = f.caller;
+}
+</pre>
+
+<p>o loop nunca irá parar.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Verificando_o_valor_da_propriedade_caller_de_uma_função">Verificando o valor da propriedade <code>caller</code> de uma função</h3>
+
+<p>O código a seguir verifica o valor da propriedade <code>caller</code> de uma função.</p>
+
+<pre class="brush: js">function myFunc() {
+  if (myFunc.caller == null) {
+    return 'The function was called from the top!';
+  } else {
+    return 'This function\'s caller was ' + myFunc.caller;
+  }
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de nenhuma especificação. Implementado no JavaScript 1.5.</p>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("1.0")}}</td>
+   <td>8.0</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("1.0")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>Implementation bug for SpiderMonkey {{bug(65683)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html b/files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html
new file mode 100644
index 0000000000..5cf33d8080
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/displayname/index.html
@@ -0,0 +1,80 @@
+---
+title: Function.displayName
+slug: Web/JavaScript/Reference/Global_Objects/Function/displayName
+tags:
+  - Função
+  - JavaScript
+  - Non Standard
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/displayName
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>A propriedade <code><strong><em>function</em>.displayName</strong></code> retorna o nome de exibição da função.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Quando definida, a propriedade <code>displayName</code> retorna o nome de exibição da função.</p>
+
+<pre class="brush: js">function doSomething() {}
+
+console.log(doSomething.displayName); // "undefined"
+
+var popup = function(content) { console.log(content); };
+
+popup.displayName = 'Show Popup';
+
+console.log(popup.displayName); // "Show Popup"
+</pre>
+
+<p>Você pode definir uma função com uma nome de exibição em um {{jsxref("Functions", "function expression", "", 1)}}:</p>
+
+<pre class="brush: js">var object = {
+  someMethod: function() {}
+};
+
+object.someMethod.displayName = 'someMethod';
+
+console.log(object.someMethod.displayName); // logs "someMethod"
+
+try { someMethod } catch(e) { console.log(e); }
+// ReferenceError: someMethod is not defined
+</pre>
+
+<p>Você pode mudar dinamicamente o<code>displayName</code> de uma função:</p>
+
+<pre class="brush: js">var object = {
+  // anonymous
+  someMethod: function(value) {
+    arguments.callee.displayName = 'someMethod (' + value + ')';
+  }
+};
+
+console.log(object.someMethod.displayName); // "undefined"
+
+object.someMethod('123')
+console.log(object.someMethod.displayName); // "someMethod (123)"
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Geralmente, é preferida por consoles e perfis em vez de  {{jsxref("Function.name", "func.name")}} mostrar o nome de uma função.</p>
+
+<p>Entrando com o seguinte em um console, isso deverá mostrar algo como  "<code>function My Function()</code>":</p>
+
+<pre class="brush: js">var a = function() {};
+a.displayName = 'My Function';
+
+a; // "function My Function()"</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de denhuma especificação.</p>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nessa página é gerada de dados estruturados. Se você gostaria de contribuir com os dados, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</div>
+
+<p>{{Compat("javascript.builtins.Function.displayName")}}</p>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/index.html b/files/pt-br/web/javascript/reference/global_objects/function/index.html
new file mode 100644
index 0000000000..fa6e32e2b1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/index.html
@@ -0,0 +1,234 @@
+---
+title: Function
+slug: Web/JavaScript/Reference/Global_Objects/Function
+tags:
+  - Constructor
+  - Function
+  - JavaScript
+  - NeedsTranslation
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Global_Objects/Function
+---
+<div>{{JSRef("Global_Objects", "Function")}}</div>
+
+<h2 id="Summary" name="Summary"><span class="short_text" id="result_box" lang="pt"><span class="hps">Resumo</span></span></h2>
+
+<p>O <strong><code>construtor Function</code></strong> cria um novo objeto <code>Function</code>. Chamar o construtor diretamente pode criar funções dinamicamente, mas sofre com problemas de segurança e desempenho semelhante (mas muito menos significativo) a {{jsxref("eval")}}. No entanto, diferentemente de eval, a Função construtora cria funções que executam somente no escopo global.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
+ <dd>Nomes para serem usandos pela função como nomes formais de argumentos. Cada um deve ser uma string que corresponde para uma válida identidade JavaScript ou uma lista de certas strings separadas com uma <span class="short_text" id="result_box" lang="pt"><span class="hps">vírgula; por exemplo "x", "theValue". our "a,b".</span></span></dd>
+ <dt><code>functionBody</code></dt>
+ <dd>Uma string que contém as <span id="result_box" lang="pt"><span class="hps">instruções </span></span>JavaScript que <span id="result_box" lang="pt"><span class="hps">compõem </span></span><span class="short_text" id="result_box" lang="pt"><span class="hps">a definição da função.</span></span></dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Objetos <code>Function</code> criados com o construtor <code>Function</code> são <em>parseados</em> quando a função é criada. Isto é menos eficiente que criar com uma <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/function">expressão de função</a> ou um <a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/function">declaração de função</a> e chamando-a dentro do seu código, porque tais funções são <em>parseadas</em> com o resto do código.</p>
+
+<p>Todos os argumentos passados para a função são tratados como os nomes dos indetificadores dos parâmetros na função a ser criada, na mesma ordem na qual eles foram passados.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> Funções criadas com o construtor <code>Function não criam closures</code> para o seu contexto de criação; elas sempre são criadas no escopo global. Quando executadas, elas terão acesso apenas às suas variáveis locais ou globais, não terão acesso às variáveis do escopo na qual o construtor <code>Function</code> foi chamado. Isto é diferente de usar {{jsxref("Global_Objects/eval", "eval")}} com o código de uma expressão de função.</p>
+</div>
+
+<p>Invocar o construtor <code>Function</code> como uma função (sem usar o operador <code>new</code>) tem o mesmo efeito de chamá-la como um construtor.</p>
+
+<h2 id="Propriedades_e_Métodos_da_Function">Propriedades e Métodos da <code>Function</code></h2>
+
+<p>O objeto global <code>Function</code> não tem métodos ou propriedades próprias, no entanto, como ela é uma função, ela herda alguns métodos e propriedades através do prototype chain do {{jsxref("Function.prototype")}}.</p>
+
+<h2 id="Function_prototype_object"><code>Function</code> prototype object</h2>
+
+<h3 id="Propriedades">Propriedades</h3>
+
+<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}</div>
+
+<h3 id="Methods" name="Methods">Métodos</h3>
+
+<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}</div>
+
+<h2 id="Function_instances" name="Function_instances"><code>Function</code> instances</h2>
+
+<p><code>Function</code> instances inherit methods and properties from {{jsxref("Function.prototype")}}. As with all constructors, you can change the constructor's prototype object to make changes to all <code>Function</code> instances.</p>
+
+<h2 id="Examples" name="Examples">Exemplos:</h2>
+
+<h3 id="Example.3A_Specifying_arguments_with_the_Function_constructor" name="Example.3A_Specifying_arguments_with_the_Function_constructor">Exemplos: Especificando argumentos com o construtor <code>Function</code></h3>
+
+<p>O código a seguir cria um objeto <code>Function</code> que recebe dois argumentos.</p>
+
+<pre class="brush: js">// O exemplo pode ser executado direto no seu console JavaScript
+
+// Cria uma função que recebe 2 argumentos e retorna a soma entre os dois:
+var adder = new Function('a', 'b', 'return a + b');
+
+// Chamada da função
+adder(2, 6);
+// &gt; 8
+</pre>
+
+<p>Os argumentos "<code>a</code>" e "<code>b</code>" são os argumentos que serão usados no corpo da função, "<code>return a + b</code>".</p>
+
+<h3 id="Example_A_recursive_shortcut_to_massively_modify_the_DOM" name="Example:_A_recursive_shortcut_to_massively_modify_the_DOM">Exemplo: Um atalho recursivo para modificar o DOM em massa</h3>
+
+<p>Creating functions with the <code>Function</code> constructor is one of the ways to dynamically create an indeterminate number of new objects with some executable code into the global scope from a function. The following example (a recursive shortcut to massively modify the DOM) is impossible without the invocation of the <code>Function</code> constructor for each new query if you want to avoid closures.</p>
+
+<pre class="brush: html">&lt;!doctype html&gt;
+&lt;html&gt;
+&lt;head&gt;
+&lt;meta http-equiv="Content-Type" content="text/html; charset=UTF-8" /&gt;
+&lt;title&gt;MDN Example - a recursive shortcut to massively modify the DOM&lt;/title&gt;
+&lt;script type="text/javascript"&gt;
+var domQuery = (function() {
+  var aDOMFunc = [
+    Element.prototype.removeAttribute,
+    Element.prototype.setAttribute,
+    CSSStyleDeclaration.prototype.removeProperty,
+    CSSStyleDeclaration.prototype.setProperty
+  ];
+
+  function setSomething(bStyle, sProp, sVal) {
+    var bSet = Boolean(sVal), fAction = aDOMFunc[bSet | bStyle &lt;&lt; 1],
+        aArgs = Array.prototype.slice.call(arguments, 1, bSet ? 3 : 2),
+        aNodeList = bStyle ? this.cssNodes : this.nodes;
+
+    if (bSet &amp;&amp; bStyle) { aArgs.push(''); }
+    for (
+      var nItem = 0, nLen = this.nodes.length;
+      nItem &lt; nLen;
+      fAction.apply(aNodeList[nItem++], aArgs)
+    );
+    this.follow = setSomething.caller;
+    return this;
+  }
+
+  function setStyles(sProp, sVal) { return setSomething.call(this, true, sProp, sVal); }
+  function setAttribs(sProp, sVal) { return setSomething.call(this, false, sProp, sVal); }
+  function getSelectors() { return this.selectors; };
+  function getNodes() { return this.nodes; };
+
+  return (function(sSelectors) {
+    var oQuery = new Function('return arguments.callee.follow.apply(arguments.callee, arguments);');
+    oQuery.selectors = sSelectors;
+    oQuery.nodes = document.querySelectorAll(sSelectors);
+    oQuery.cssNodes = Array.prototype.map.call(oQuery.nodes, function(oInlineCSS) { return oInlineCSS.style; });
+    oQuery.attributes = setAttribs;
+    oQuery.inlineStyle = setStyles;
+    oQuery.follow = getNodes;
+    oQuery.toString = getSelectors;
+    oQuery.valueOf = getNodes;
+    return oQuery;
+  });
+})();
+&lt;/script&gt;
+&lt;/head&gt;
+
+&lt;body&gt;
+
+&lt;div class="testClass"&gt;Lorem ipsum&lt;/div&gt;
+&lt;p&gt;Some text&lt;/p&gt;
+&lt;div class="testClass"&gt;dolor sit amet&lt;/div&gt;
+
+&lt;script type="text/javascript"&gt;
+domQuery('.testClass')
+  .attributes('lang', 'en')('title', 'Risus abundat in ore stultorum')
+  .inlineStyle('background-color', 'black')('color', 'white')('width', '100px')('height', '50px');
+&lt;/script&gt;
+&lt;/body&gt;
+
+&lt;/html&gt;
+</pre>
+
+<h2 id="Especificação">Especificação</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>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Operators/function", "function Expression", "", 1)}}</li>
+ <li>{{jsxref("Statements/function", "function Statement", "", 1)}}</li>
+ <li>{{jsxref("Functions_and_function_scope", "Functions and function scope", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html b/files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html
new file mode 100644
index 0000000000..b370305940
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/isgenerator/index.html
@@ -0,0 +1,55 @@
+---
+title: Function.prototype.isGenerator()
+slug: Web/JavaScript/Reference/Global_Objects/Function/isGenerator
+tags:
+  - Função
+  - Não padronizados
+  - Obsoleto
+  - metodo
+translation_of: Archive/Web/JavaScript/Function.isGenerator
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O método não padronizado <code><strong>isGenerator()</strong></code> é usado para determinar se uma função é ou não um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">gerador</a>. Ele foi removido do Firefox a partir da versão 58.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>fun</var>.isGenerator()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} que indica se dada função é ou nao um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">gerador</a>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>isGenerator()</code> determina se uma função <em><code>fun</code></em> é ou não um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators#Generators.3A_a_better_way_to_build_Iterators">gerador</a>. Fez parte de uma Proposta Inicial de Harmonia, mas não foi incluído na especificação do ECMAScript 2015.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">function f() {}
+
+function* g() {
+  yield 42;
+}
+
+console.log('f.isGenerator() = ' + f.isGenerator()); // f.isGenerator() = false
+console.log('g.isGenerator() = ' + g.isGenerator()); // g.isGenerator() = true
+</pre>
+
+<h2 id="Specificações">Specificações</h2>
+
+<p>Não faz parte de nenhuma especificação. Implementado no JavaScript 1.8.6.</p>
+
+<h2 id="Compatibilidade_do_Navegador">Compatibilidade do Navegador</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estrurados. Se você não quiser contribuir com estes dados, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um pull request.</div>
+
+<p>{{Compat("javascript.builtins.Function.isGenerator")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iteradores e geradores</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/length/index.html b/files/pt-br/web/javascript/reference/global_objects/function/length/index.html
new file mode 100644
index 0000000000..a116f07892
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/length/index.html
@@ -0,0 +1,134 @@
+---
+title: Function.length
+slug: Web/JavaScript/Reference/Global_Objects/Function/length
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/length
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code><strong>length</strong></code> especifica o número de argumentos esperados pela função.</p>
+
+<div>{{js_property_attributes(0,0,1)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>length é uma propriedade de um objeto função</code>, e indica quantos argumentos a função espera, i.e. o número de parametros formais. Este número não incluí o {{jsxref("rest_parameters", "rest parameter", "", 1)}}. <span class="short_text" id="result_box" lang="pt"><span>Por contraste,</span></span> {{jsxref("Functions_and_function_scope/arguments/length", "arguments.length")}} é local para a função e fornece o número de argumentos que foram realmente passados.</p>
+
+<h3 id="Propriedade_de_Dados_do_construtor_Function">Propriedade de Dados do construtor <code>Function</code></h3>
+
+<p>O construtor {{jsxref("Function")}} é propriamente um objeto {{jsxref("Function")}}. A proproedade de dados do seu <code>length</code> tem o valor de 1. Os atributos da propriedade são: Escrita: <code>false</code>, Enumerável: <code>false</code>, Configurável: <code>true</code>.</p>
+
+<h3 id="Propriedades_do_objeto_prototype_de_Function">Propriedades do objeto prototype de <code>Function</code></h3>
+
+<p>A propriedade length do objeto prototype {{jsxref("Function")}} tem o valor de 0.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js notranslate">console.log(Function.length); /* 1 */
+
+console.log((function()        {}).length); /* 0 */
+console.log((function(a)       {}).length); /* 1 */
+console.log((function(a, b)    {}).length); /* 2 etc. */
+console.log((function(...args) {}).length); /* 0, rest parameter is not counted */
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.5.1', 'Function.length')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-instances-length', 'Function.length')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>The <code>configurable</code> attribute of this property is now <code>true</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_o_Navegador">Compatibilidade com o Navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Configurable: true</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop(37)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Configurable: true</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile(37)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_tambem">Veja tambem</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/name/index.html b/files/pt-br/web/javascript/reference/global_objects/function/name/index.html
new file mode 100644
index 0000000000..2ee74e0779
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/name/index.html
@@ -0,0 +1,222 @@
+---
+title: Function.name
+slug: Web/JavaScript/Reference/Global_Objects/Function/name
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/name
+---
+<div>{{JSRef}}</div>
+
+<p><span class="seoSummary">A propriedade somente-leitura <code><strong>name</strong></code> de um objeto {{jsxref("Function")}} indica o nome da função como especificado quando esta foi criada, ou <code>"anonymous"</code> para funções criadas anonimamente.</span></p>
+
+<div>{{EmbedInteractiveExample("pages/js/function-name.html")}}</div>
+
+<p class="hidden">O código-fonte deste exemplo interativo está mantido em um repositório do GitHub. Se você gostaria de contribuir com o projeto de exemplos interativos, clone por favor <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um <em>pull request</em>.</p>
+
+<div>{{js_property_attributes(0,0,1)}}<br>
+ </div>
+
+<div class="note">
+<p>Note que em implementações não-standard anteriores à ES2015 o atributo <code>configurable</code> tinha também o valor <code>false</code>.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Nome_de_declaração_da_função">Nome de declaração da função</h3>
+
+<p>A propriedade <code>name</code> retorna o nome de uma declaração de função.</p>
+
+<pre class="brush: js">function doSomething() {}
+doSomething.name; // "doSomething"
+</pre>
+
+<h3 id="Nome_do_construtor_da_função">Nome do construtor da função</h3>
+
+<p>Funções criadas com a sintaxe <code>new Function(...)</code> ou somente <code>Function(...)</code> criam objetos {{jsxref("Function")}} com o nome "anonymous".</p>
+
+<pre>(new Function).name; // "anonymous"</pre>
+
+<h3 id="Nomes_de_função_inferidos">Nomes de função inferidos</h3>
+
+<p>Variáveis e métodos podem inferir o nome de uma função anônima a partir de sua posição sintática (novo na ECMAScript 2015).</p>
+
+<pre class="brush: js">var f = function() {};
+var object = {
+  someMethod: function() {}
+};
+
+console.log(f.name); // "f"
+console.log(object.someMethod.name); // "someMethod"
+</pre>
+
+<p>Você pode definir uma função com um nome numa {{jsxref("Operators/Function", "expressão de função", "", 1)}}:</p>
+
+<pre class="brush: js">var object = {
+  someMethod: function object_someMethod() {}
+};
+console.log(object.someMethod.name); // grava o log "object_someMethod"
+
+try { object_someMethod } catch(e) { console.log(e); }
+// ReferenceError: object_someMethod is not defined
+</pre>
+
+<p>Você não pode mudar o nome de uma função, pois a propriedade é somente-leitura:</p>
+
+<div class="hidden">
+<p>O exemplo abaixo contradiz o que é dito no começo desta seção e não funciona como descrito.</p>
+</div>
+
+<pre class="brush: js">var object = {
+  // anonymous
+  someMethod: function() {}
+};
+
+object.someMethod.name = 'otherMethod';
+console.log(object.someMethod.name); // someMethod
+</pre>
+
+<p>Para mudá-lo, você poderia no entanto usar {{jsxref("Object.defineProperty()")}}.</p>
+
+<h3 id="Nomes_curtos_de_métodos">Nomes curtos de métodos</h3>
+
+<pre class="brush: js">var o = {
+  foo(){}
+};
+o.foo.name; // "foo";</pre>
+
+<h3 id="Nomes_de_funções_vinculadas">Nomes de funções vinculadas</h3>
+
+<p>{{jsxref("Function.bind()")}} produz uma função cujo nome é "bound " seguido do nome da função.</p>
+
+<pre class="brush: js">function foo() {};
+foo.bind({}).name; // "bound foo"
+</pre>
+
+<h3 id="Nomes_de_função_para_getters_e_setters">Nomes de função para <em>getters</em> e <em>setters</em></h3>
+
+<p>Ao usar propriedades acessórias <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/get">get</a></code> e <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">set</a></code>, "get" ou "set" aparecerão no nome da função.</p>
+
+<pre class="brush: js">var o = {
+  get foo(){},
+  set foo(x){}
+};
+
+var descriptor = Object.getOwnPropertyDescriptor(o, "foo");
+descriptor.get.name; // "get foo"
+descriptor.set.name; // "set foo";</pre>
+
+<h3 id="Nomes_de_funções_em_classes">Nomes de funções em classes</h3>
+
+<p>Você pode usar <code>obj.constructor.name</code> para checar a "classe" de um objeto (porém leia com atenção os avisos abaixo):</p>
+
+<pre class="brush: js">function Foo() {}  // Sintaxe ES2015: class Foo {}
+
+var fooInstance = new Foo();
+console.log(fooInstance.constructor.name); // grava o log "Foo"
+</pre>
+
+<div class="warning">
+<p><strong>Aviso:</strong> O interpretador vai definir a propriedade  interna <code>Function.name</code> somente se uma função não tiver uma propriedade já com o nome <em>name</em> (veja a seção <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-setfunctionname">9.2.11 da ECMAScript2015 Language Specification</a>). Porém, a ES2015 especifica que a palavra-chave <em>static</em> de maneira que métodos estáticos serão definidos como OwnProperty da função construtora de classe (ECMAScript2015, <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-runtime-semantics-classdefinitionevaluation">14.5.14.21.b</a> + <a href="https://www.ecma-international.org/ecma-262/6.0/#sec-object-initializer-runtime-semantics-propertydefinitionevaluation">12.2.6.9</a>).</p>
+</div>
+
+<p>Portanto não podemos obter o nome de virtualmente qualquer classe com um método estático <code>name()</code>:</p>
+
+<pre class="brush: js">class Foo {
+  constructor() {}
+  static name() {}
+}
+</pre>
+
+<p>Com um método <code>static name()</code>, <code>Foo.name</code> não guarda mais o nome verdadeiro da classe mas uma referência ao objeto de função <code>name()</code>. A definição de classe acima, escrita em sintaxe ES2015, se comportará de maneira similar ao seguinte trecho de código em sintaxe ES5 no Chrome ou no Firefox:</p>
+
+<pre class="brush: js">function Foo() {}
+Object.defineProperty(Foo, 'name', { writable: true });
+Foo.name = function() {};
+</pre>
+
+<p>Tentar obter a classe de <code>fooInstance</code> via <code>fooInstance.constructor.name</code> não nos dará de maneira alguma o nome da classe, mas sim uma referência ao método estático da classe. Exemplo:</p>
+
+<pre class="brush: js">var fooInstance = new Foo();
+console.log(fooInstance.constructor.name); // grava o name() da função no log
+</pre>
+
+<p>Você pode ver também, a partir do exemplo de sintaxe ES5, que, no Chrome ou no Firefox, a nossa definição estática de <code>Foo.name</code> se torna <em>writable</em>. A predefinição interna na ausência de uma definição estática customizada é somente-leitura:</p>
+
+<pre class="brush: js">Foo.name = 'Hello';
+console.log(Foo.name); // logs "Hello" if class Foo has a static name() property but "Foo" if not.
+</pre>
+
+<p>Portanto, você não pode assumir que a propriedade interna <code>Function.name</code> sempre guardará um nome de classe..</p>
+
+<h3 id="Símbolos_como_nome_de_função">Símbolos como nome de função</h3>
+
+<p>Se um {{jsxref("Symbol")}} é usado como nome de função e o símbolo tem uma descrição, o nome do método será a descrição entre colchetes.</p>
+
+<pre>var sym1 = Symbol("foo");
+var sym2 = Symbol();
+var o = {
+  [sym1]: function(){},
+  [sym2]: function(){}
+};
+
+o[sym1].name; // "[foo]"
+o[sym2].name; // ""</pre>
+
+<h2 id="Compressores_e_minificadores_JavaScript">Compressores e minificadores JavaScript</h2>
+
+<div class="warning">
+<p><strong>Aviso:</strong> Tenha cuidado ao usar <code>Function.name</code> e transformações de código-fonte, como aquelas executadas por compressores (minificadores) ou obfuscadores de JavaScript. Estas ferramentas são comumente usadas como parte de processos de <em>build  </em>de JavaScript para reduzir os tamanhos de programas antes da implementação em produção. Tais transformações frequentemente mudam nomes de função durante o <em>build</em>.</p>
+</div>
+
+<p>Código fonte do tipo:</p>
+
+<pre class="brush: js">function Foo() {};
+var foo = new Foo();
+
+if (foo.constructor.name === 'Foo') {
+  console.log("'foo' is an instance of 'Foo'");
+} else {
+  console.log('Oops!');
+}
+</pre>
+
+<p>pode ser comprimido e se tornar:</p>
+
+<pre class="brush: js">function a() {};
+var b = new a();
+if (b.constructor.name === 'Foo') {
+  console.log("'foo' is an instance of 'Foo'");
+} else {
+  console.log('Oops!');
+}
+</pre>
+
+<p>Na versão descomprimida, o programa cai no bloco-verdade e grava o log <em>'foo' is an instance of 'Foo'</em>. Todavia, na versão comprimida ele se comporta diferentemente, e cai no bloco <code>else</code>. Se você depende de <code>Function.name</code>, como no exemplo acima, tenha certeza que seu processo de <em>build</em> não mude nomes de função, ou então não assuma que uma função terá um nome determinado.</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>{{SpecName('ES2015', '#sec-name', 'name')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function-instances-name', 'name')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você gostaria de contribuir com os dados, confira por favor <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Function.name")}}</p>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html
new file mode 100644
index 0000000000..285bf56281
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/prototype/index.html
@@ -0,0 +1,94 @@
+---
+title: Function.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Function/prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Function
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code><strong>Function.prototype</strong></code> representa o objeto <code>prototype</code> de {{jsxref("Function")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Objetos {{jsxref("Function")}} herdam de <code>Function.prototype</code>.  <code>Function.prototype</code> não pode ser modificado.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("Function.arguments")}} {{deprecated_inline}}</dt>
+ <dd>Um vetor correspondente aos argumentos passados a uma função. Isto é depreciado como propriedade de {{jsxref("Function")}}. Use em vez disso o objeto {{jsxref("Functions/arguments", "arguments")}} disponível dentro da função.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("Function.arity")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Usado para especificar o número de argumentos esperados pela função. Foi removido, utilize em vez disso a propriedade {{jsxref("Function.length", "length")}}.</s></dd>
+ <dt>{{jsxref("Function.caller")}} {{non-standard_inline}}</dt>
+ <dd>Especifica a função que invocou a função sendo executada.</dd>
+ <dt>{{jsxref("Function.length")}}</dt>
+ <dd>Especifica o número de argumentos esperados pela função.</dd>
+ <dt>{{jsxref("Function.name")}}</dt>
+ <dd>O nome da função.</dd>
+ <dt>{{jsxref("Function.displayName")}} {{non-standard_inline}}</dt>
+ <dd>O nome de exibição da função.</dd>
+ <dt><code>Function.prototype.constructor</code></dt>
+ <dd>Especifica a função que cria o <code>prototype</code> do objeto. Veja {{jsxref("Object.prototype.constructor")}} para mais detalhes.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Function.prototype.apply()")}}</dt>
+ <dd>Chama uma função e define seu <code>this</code> com o valor fornecido. Argumentos podem ser passados como um objeto {{jsxref("Array")}}.</dd>
+ <dt>{{jsxref("Function.prototype.bind()")}}</dt>
+ <dd>Cria uma nova função que, quando chamada, tem seu <code>this</code> definido com o valor fornecido, com uma sequência de argumentos determinada precedendo quaisquer argumentos fornecidos quando a nova função é chamada.</dd>
+ <dt>{{jsxref("Function.prototype.call()")}}</dt>
+ <dd>Chama (executa) uma função e define seu <code>this</code> com o valor fornecido. Argumentos podem ser passados como são.</dd>
+ <dt>{{jsxref("Function.prototype.isGenerator()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna <code>true</code> se a função é um <a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">gerador</a>; se não, retorna <code>false</code>.</dd>
+ <dt>{{jsxref("Function.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna uma <em>string</em> representando o código-fonte da função. Sobrescreve o método {{jsxref("Object.prototype.toSource")}}.</dd>
+ <dt>{{jsxref("Function.prototype.toString()")}}</dt>
+ <dd>Retorna uma <em>string</em> representando o código-fonte da função. Sobrescreve o método {{jsxref("Object.prototype.toString")}}.</dd>
+</dl>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.3.5.2', 'Function.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-instances-prototype', 'Function.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function-instances-prototype', 'Function.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibildiade nesta página é gerada a partir de dados estruturados. Se você gostaria de contribuir com os dados, confira por favor <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Function.prototype")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html
new file mode 100644
index 0000000000..4fbeaaf1c1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/tosource/index.html
@@ -0,0 +1,57 @@
+---
+title: Function.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Function/toSource
+tags:
+  - Função
+  - JavaScript
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O método <code><strong>toSource()</strong></code> retorna uma string que representa o código-fonte do objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>function</var>.toSource();
+Function.toSource();
+</pre>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>Uma string representa o código-fonte de um objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método<code>toSource</code> retorna os seguintes valores:</p>
+
+<ul>
+ <li>Para objetos nativos {{jsxref("Function")}} , <code>toSource()</code> retorna a seguinte string indicando que o código-fonte não está disponível:
+
+  <pre class="brush: js">function Function() {
+    [native code]
+}
+</pre>
+ </li>
+ <li>Para funções personalizadas, <code>toSource()</code> retorna a fonte JavaScript que define o objeto como uma string.</li>
+</ul>
+
+<p>Esse método, normalmente é chamado internamente pelo JavaScript e não explicitamente no código. Você pode chamar <code>toSource</code> enquanto depura para examinar o conteúdo de um objeto.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de nenhum padrão. Implementado no JavaScript 1.3.</p>
+
+<h2 id="Compatibilidade_em_Navegadores">Compatibilidade em Navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de comaptibilidade nessa página é gerada por dados estruturados. Se você gostaria de contribuir para os dados, por favor, veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande um pull-request.</div>
+
+<p>{{Compat("javascript.builtins.Function.toSource")}}</p>
+</div>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html
new file mode 100644
index 0000000000..c4d6fbbfb6
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/function/tostring/index.html
@@ -0,0 +1,239 @@
+---
+title: Function.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Function/toString
+tags:
+  - Função
+  - JavaScript
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Function/toString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>toString()</strong></code> retorna uma string representando o código fonte da função.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/function-tostring.html")}}</div>
+
+<p class="hidden">A fonte deste exemplo interativo está armazenado no repositório do GitHub. Se você gostaria de contrubuir para este exemplos de projeto interativo, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>function</var>.toString()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma string representando o código fonte da função.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O objeto da {{jsxref("Function")}} substitui o método {{jsxref("Object.prototype.toString", "toString")}} herdado de {{jsxref("Object")}}; ele não herda {{jsxref("Object.prototype.toString")}}. Para objetos {{jsxref("Function")}} definidos pelo usuário, o método <code>toString</code> retorna uma string contendo o seguimento de texto de origem que foi usado para definir a função</p>
+
+<p>O JavaScript chama o método <code>toString</code> automaticamente quando uma {{jsxref("Function")}} pode ser representada como um valor de texto. e.x. quando uma função é concatenada com uma string.</p>
+
+<p>O método <code>toString()</code> lançará uma exceção do tipo {{jsxref("TypeError")}} ("Function.prototype.toString called on incompatible object") se o valor <code>this</code> do objeto não é um objeto do tipo <code>Function.</code></p>
+
+<pre class="brush: js example-bad notranslate">Function.prototype.toString.call('foo'); // TypeError
+</pre>
+
+<p>Se o método <code>toString()</code> é chamado por objetos de funções embutidas ou por uma função criada por <code>Function.prototype.bind</code>, <code>toString()</code> retorna uma string de uma função nativa que parece</p>
+
+<pre class="brush: js notranslate">"function () {\n    [native code]\n}"
+</pre>
+
+<p>Se o método <code>toString()</code> é chamado por uma função criada pelo contrutor de <code>Function</code>, <code>toString()</code> retorna o código fonte de uma declaração de função sintetizada chamada "anonymous" usando os parâmetros passados e o corpo da função.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Função</th>
+   <th scope="col">Function.prototype.toString resultado</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>
+    <pre class="notranslate">
+function f(){}</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function f(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+class A { a(){} }</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"class A { a(){} }"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+function* g(){}</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function* g(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+a =&gt; a</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"a =&gt; a"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+({ a(){} }.a)</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"a(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+({ *a(){} }.a)</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"*a(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+({ [0](){} }[0])</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"[0](){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+Object.getOwnPropertyDescriptor({
+    get a(){}
+}, "a").get</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"get a(){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+Object.getOwnPropertyDescriptor({
+    set a(x){}
+}, "a").set</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"set a(x){}"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+Function.prototype.toString</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function toString() { [native code] }"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+(function f(){}.bind(0))</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function () { [native code] }"</pre>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <pre class="notranslate">
+Function("a", "b")</pre>
+   </td>
+   <td>
+    <pre class="notranslate">
+"function anonymous(a\n) {\nb\n}"</pre>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>
+    <p>Definição inicial. Implementado no JavaScript 1.1.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>
+    <p>Mais requisitos específicos foram incluídos para representação de string.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><a href="https://tc39.github.io/Function-prototype-toString-revision/#sec-introduction"><code>Function.prototype.toString</code> revisions proposal</a></td>
+   <td>Rascunho</td>
+   <td>
+    <p>Padroniza a função de string navida e fins de linha.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function.prototype.tostring', 'Function.prototype.toString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Function.toString")}}</p>
+</div>
+
+<h2 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h2>
+
+<ul>
+ <li>Desde o Firefox 17 a função <code>Function.prototype.toString()</code> tem sido implementada salvando o fonte da função. O descompilador foi removido o que torna o parâmetro <code>indentation</code> desnecessário. Veja {{bug("761723")}} para mais detalhes.</li>
+ <li>Do Firefox 38 para o 63 a função <code>Function.prototype.toString()</code> lançava exceções para objetos {{jsxref("Proxy")}} ({{bug(1100936)}} e {{bug(1440468)}}).</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/generator/index.html b/files/pt-br/web/javascript/reference/global_objects/generator/index.html
new file mode 100644
index 0000000000..6bcf4652df
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/generator/index.html
@@ -0,0 +1,178 @@
+---
+title: Generator
+slug: Web/JavaScript/Reference/Global_Objects/Generator
+translation_of: Web/JavaScript/Reference/Global_Objects/Generator
+---
+<div>{{JSRef}}</div>
+
+<p>O objeto <code><strong>Generator</strong></code> é retornado por {{jsxref("Statements/function*", "generator function", "", 1)}} e conforme <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable">iterable protocol</a> e o <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterator">iterator protocol</a>.</p>
+
+<h2 id="Síntaxe">Síntaxe</h2>
+
+<pre class="syntaxbox">function* gen() {
+  yield 1;
+  yield 2;
+  yield 3;
+}
+
+var g = gen(); // "Generator { }"</pre>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Generator.prototype.next()")}}</dt>
+ <dd>Retorna o valor fornecido pela expressão {{jsxref("Operators/yield", "yield")}}.</dd>
+ <dt>{{jsxref("Generator.prototype.return()")}}</dt>
+ <dd>Retorna o valor fornecido a finaliza o generator.</dd>
+ <dt>{{jsxref("Generator.prototype.throw()")}}</dt>
+ <dd>Lança um erro no generator.</dd>
+</dl>
+
+<h2 id="Example">Example</h2>
+
+<h3 id="An_infinite_iterator">An infinite iterator</h3>
+
+<pre class="brush: js">function* idMaker(){
+    var index = 0;
+    while(true)
+        yield index++;
+}
+
+var gen = idMaker(); // "Generator { }"
+
+console.log(gen.next().value); // 0
+console.log(gen.next().value); // 1
+console.log(gen.next().value); // 2
+// ...</pre>
+
+<h2 id="Objeto_legacy_generator">Objeto legacy generator</h2>
+
+<p>Firefox (SpiderMonkey) também implementa a versão anterior do generator em <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.7">JavaScript 1.7</a>, onde o asterisco (*) na declaração da função não era necessário (somente era necessário usar a palavra reservada <code>yield</code> no corpo da função). Contudo, legacy generators estão obsoletos. Não os use, eles serão removidos ({{bug(1083482)}}).</p>
+
+<h3 id="Métodos_legacy_generator">Métodos legacy generator</h3>
+
+<dl>
+ <dt><code>Generator.prototype.next() </code>{{non-standard_inline}}</dt>
+ <dd>Retorna o valor fornecido pela expressão {{jsxref("Operators/yield", "yield")}}. Isto corresponde ao <code>next() </code>do ES6.</dd>
+ <dt><code>Generator.prototype.close()</code> {{non-standard_inline}}</dt>
+ <dd>Fecha o generator, então quando chamar <code>next()</code> um erro {{jsxref("StopIteration")}}  será lançado. Isto corresponde ao  método <code>return()</code> do ES6.</dd>
+ <dt><code>Generator.prototype.send()</code> {{non-standard_inline}}</dt>
+ <dd>Usado para enviar um valor para o generator. Este valor é retordo pela expressão {{jsxref("Operators/yield", "yield")}}, e retorna o valor fornecido pelo pelo next {{jsxref("Operators/yield", "yield")}}. <code>send(x)</code> corresponde ao <code>next(x)</code> do ES6.</dd>
+ <dt><strong><code>Generator.</code></strong><code>prototype.</code><strong><code>throw()</code> </strong> {{non-standard_inline}}</dt>
+ <dd>Lança um erro no generator. Isto corresponde ao método <code>throw() do ES6.</code></dd>
+</dl>
+
+<h3 id="Exemplo_do_Legacy_generator">Exemplo do Legacy generator</h3>
+
+<pre class="brush: js">function* fibonacci() {
+  var a = yield 1;
+  yield a * 2;
+}
+
+var it = fibonacci();
+console.log(it);          // "Generator {  }"
+console.log(it.next());   // 1
+console.log(it.send(10)); // 20
+console.log(it.close());  // undefined
+console.log(it.next());   // throws StopIteration (Como o generator está fechado)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-generator-objects', 'Generator objects')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição Inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-generator-objects', 'Generator objects')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(39.0)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(39.0)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(39.0)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<h3 id="Legacy_generators">Legacy generators</h3>
+
+<ul>
+ <li>{{jsxref("Statements/Legacy_generator_function", "The legacy generator function", "", 1)}}</li>
+ <li>{{jsxref("Operators/Legacy_generator_function", "The legacy generator function expression", "", 1)}}</li>
+ <li>{{jsxref("StopIteration")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Deprecated_and_obsolete_features/The_legacy_Iterator_protocol">The legacy Iterator protocol</a></li>
+</ul>
+
+<h3 id="ES6_generators">ES6 generators</h3>
+
+<ul>
+ <li>{{jsxref("Functions", "Functions", "", 1)}}</li>
+ <li>{{jsxref("Statements/function", "function")}}</li>
+ <li>{{jsxref("Operators/function", "function expression")}}</li>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("Statements/function*", "function*")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("GeneratorFunction")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/globalthis/index.html b/files/pt-br/web/javascript/reference/global_objects/globalthis/index.html
new file mode 100644
index 0000000000..2fa51a26e2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/globalthis/index.html
@@ -0,0 +1,80 @@
+---
+title: globalThis
+slug: Web/JavaScript/Reference/Global_Objects/globalThis
+tags:
+  - JavaScript
+  - Reference
+  - global
+  - globalThis
+translation_of: Web/JavaScript/Reference/Global_Objects/globalThis
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p>A propriedade global <code><strong>globalThis</strong></code> retorna um objeto global de nível superior.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/globalprops-globalthis.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>globalThis</code>
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Historicamente, o acesso ao escopo global exigiu uma sintaxe diferente em diferentes ambientes JavaScript. Na web você pode usar <code><a href="/en-US/docs/Web/API/Window/window">window</a></code>, <code><a href="/en-US/docs/Web/API/Window/self">self</a></code> ou <code><a href="/en-US/docs/Web/API/Window/frames">frames</a></code> - porém em <a href="/en-US/docs/Web/API/Worker">Web Workers</a> somente <code>self</code> funcionará. Em Node.js nada disso funciona e você deve usar <code>global</code>.<br>
+ A palavra-chave <code>this</code> poderia ser usada dentro de funções em execução no modo <em>sloppy</em>, mas <code>this</code> será <code>undefined</code> em módulos, e dentro de funções em execução no <em>strict mode</em>.</p>
+
+<p>A propriedade <code>globalThis</code> fornece uma maneira padrão de acessar o objeto global entre ambientes. Ao contrário de propriedades semelhantes, como <code><a href="/en-US/docs/Web/API/Window/window">window</a></code> e <code><a href="/en-US/docs/Web/API/Window/self">self</a></code>, é garantido que funcione em contextos <em>window</em> e <em>non-window</em>. Dessa forma, você pode acessar o objeto global de maneira consistente sem precisar saber em qual ambiente o código está sendo executado.</p>
+
+<p>Para ajudá-lo a lembrar o nome, lembre-se que no escopo global, o valor de <code>this</code> é <code>globalThis</code>.</p>
+
+<h3 id="Nome">Nome</h3>
+
+<p>Várias outras opções de nomes populares, como <code>self</code> e <code>global</code> foram removidas da discussão devido ao seu potencial em quebrar a compatibilidade com o código existente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Antes de <code>globalThis</code>, a única maneira confiável de obter o objeto global para um ambiente era <code>Function('return this')()</code>. No entanto, isso causa violações <a href="/en-US/docs/Web/HTTP/CSP">CSP</a> em algumas configurações, então <a href="https://github.com/paulmillr/es6-shim">es6-shim</a> usa uma verificação como essa, por exemplo:</p>
+
+<pre class="brush: js">var getGlobal = function () {
+  if (typeof self !== 'undefined') { return self; }
+  if (typeof window !== 'undefined') { return window; }
+  if (typeof global !== 'undefined') { return global; }
+  throw new Error('unable to locate global object');
+};
+
+var globals = getGlobal();
+
+if (typeof globals.setTimeout !== 'function') {
+  // sem setTimeout neste ambiente!
+}
+</pre>
+
+<p>Com <code>globalThis</code> disponível, a busca global adicional entre ambientes não é mais necessária:</p>
+
+<pre class="brush: js">if (typeof globalThis.setTimeout !== 'function') {
+  // sem setTimeout neste ambiente!
+}</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><a href="https://github.com/tc39/proposal-global">globalThis proposal</a></td>
+   <td>Stage 3</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<p>{{Compat("javascript.builtins.globalThis")}}</p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/index.html b/files/pt-br/web/javascript/reference/global_objects/index.html
new file mode 100644
index 0000000000..cd7eb82608
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/index.html
@@ -0,0 +1,174 @@
+---
+title: Objetos Globais
+slug: Web/JavaScript/Reference/Global_Objects
+tags:
+  - JavaScript
+  - Reference
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Global_Objects
+---
+<p></p>
+
+<div>{{jsSidebar("Objects")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>Este capítulo documenta todos os objetos nativos do JavaScript padrão, assim como seus métodos e propriedades.</p>
+
+<div class="onlyinclude">
+<p>O termo "objetos globais" (ou objetos nativos por padrão) aqui não deve ser confundido com o de <strong>objeto global</strong>. Aqui, objetos globais se referem aos <strong>objetos no escopo global</strong> (somente se o modo estrito/<em>strict mode</em> do ECMAScript 5 não for usado; Nesse caso retorna {{jsxref("undefined")}}). O <strong>objeto global</strong> pode ser acessado usando o operador {{jsxref("Operators/this", "this")}} no escopo global. De fato, o escopo global <strong>consiste em<em> </em></strong>propriedades do objeto global, incluindo propriedades herdadas, se houver.</p>
+
+<p>Outros objetos no escopo global também são <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">criados pelo desenvolvedor</a> ou fornecido pela aplicação <em>host</em>. Os objetos disponíveis no <em>host</em> no contexto do browser são documentados na <a href="https://developer.mozilla.org/en-US/docs/Web/API/Reference">API reference</a>. Para maiores informações sobre as distinções entre <a href="https://developer.mozilla.org/en-US/docs/DOM/DOM_Reference">DOM</a> e core <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript">JavaScript</a>, veja <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/JavaScript_technologies_overview">visão geral das tecnologias JavaScript</a>.</p>
+
+<h2 id="Objetos_padrão_(por_categoria)">Objetos padrão (por categoria)</h2>
+
+<h3 id="Propriedades_de_valor">Propriedades de valor</h3>
+
+<p>Propriedades globais retornam um valor simples; eles não tem propriedades ou métodos.</p>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Infinity", "Infinity")}}</li>
+ <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li>
+ <li>{{jsxref("Global_Objects/undefined", "undefined")}}</li>
+ <li>{{jsxref("Global_Objects/null", "null")}} literal</li>
+</ul>
+
+<h3 id="Propriedades_de_função">Propriedades de função</h3>
+
+<p>Estas funções globais —funções que são chamadas globalmente ao invés de em um objeto—retornam diretamente seus resultados a quem chama.</p>
+
+<ul>
+ <li>{{jsxref("Global_Objects/eval", "eval()")}}</li>
+ <li>{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline()}}</li>
+ <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li>
+ <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li>
+ <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li>
+ <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li>
+ <li>{{jsxref("Global_Objects/decodeURI", "decodeURI()")}}</li>
+ <li>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent()")}}</li>
+ <li>{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}</li>
+ <li>{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}</li>
+ <li>{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline()}}</li>
+ <li>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline()}}</li>
+</ul>
+
+<h3 id="Objetos_fundamentais">Objetos fundamentais</h3>
+
+<p>Estes são objetos básicos e fundamentais nos quais todos os outros objetos são baseados. Isso inclui objetos que representam objetos genéricos, funções e erros.</p>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Object", "Object")}}</li>
+ <li>{{jsxref("Global_Objects/Function", "Function")}}</li>
+ <li>{{jsxref("Global_Objects/Boolean", "Boolean")}}</li>
+ <li>{{jsxref("Global_Objects/Symbol", "Symbol")}} {{experimental_inline()}}</li>
+ <li>{{jsxref("Global_Objects/Error", "Error")}}</li>
+ <li>{{jsxref("Global_Objects/EvalError", "EvalError")}}</li>
+ <li>{{jsxref("Global_Objects/InternalError", "InternalError")}}</li>
+ <li>{{jsxref("Global_Objects/RangeError", "RangeError")}}</li>
+ <li>{{jsxref("Global_Objects/ReferenceError", "ReferenceError")}}</li>
+ <li>{{jsxref("Global_Objects/StopIteration", "StopIteration")}}</li>
+ <li>{{jsxref("Global_Objects/SyntaxError", "SyntaxError")}}</li>
+ <li>{{jsxref("Global_Objects/TypeError", "TypeError")}}</li>
+ <li>{{jsxref("Global_Objects/URIError", "URIError")}}</li>
+</ul>
+
+<h3 id="Números_e_datas">Números e datas</h3>
+
+<p>Estes são objetos base para a representação de números, datas e cálculos matemáticos.</p>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Number", "Number")}}</li>
+ <li>{{jsxref("Global_Objects/Math", "Math")}}</li>
+ <li>{{jsxref("Global_Objects/Date", "Date")}}</li>
+</ul>
+
+<h3 id="Processamento_de_texto">Processamento de texto</h3>
+
+<p>Estes objetos representam strings e manipulam as mesmas.</p>
+
+<ul>
+ <li>{{jsxref("Global_Objects/String", "String")}}</li>
+ <li>{{jsxref("Global_Objects/RegExp", "RegExp")}}</li>
+</ul>
+
+<h3 id="Coleções_indexadas">Coleções indexadas</h3>
+
+<p>Estes objetos representam coleções de dados que são ordenados pelo valor de um índice. Isso inclui arrays (tipados) e arrays baseados em outros construtores, como <code>[]</code>.</p>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Array", "Array")}}</li>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Float32Array" title="JavaScript_typed_arrays/Float32Array">Float32Array</a></code></li>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Float64Array" title="JavaScript_typed_arrays/Float64Array">Float64Array</a></code></li>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Int16Array" title="JavaScript_typed_arrays/Int16Array">Int16Array</a></code></li>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Int32Array" title="JavaScript_typed_arrays/Int32Array">Int32Array</a></code></li>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Int8Array" title="JavaScript_typed_arrays/Int8Array">Int8Array</a></code></li>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Uint16Array" title="JavaScript_typed_arrays/int16Array">Uint16Array</a></code></li>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Uint32Array" title="JavaScript_typed_arrays/Uint32Array">Uint32Array</a></code></li>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Uint8Array" title="JavaScript_typed_arrays/int8Array">Uint8Array</a></code></li>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/JavaScript_typed_arrays/Uint8ClampedArray" title="JavaScript_typed_arrays/Uint8ClampedArray">Uint8ClampedArray</a></code></li>
+ <li>{{jsxref("Global_Objects/ParallelArray", "ParallelArray")}} {{non-standard_inline()}}</li>
+</ul>
+
+<h3 id="Coleções_chaveadas">Coleções chaveadas</h3>
+
+<p>Estes objetos representam coleções que usam chaves; estas contém elementos que são iteráveis na ordem de inserção.</p>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Map", "Map")}} {{experimental_inline()}}</li>
+ <li>{{jsxref("Global_Objects/Set", "Set")}} {{experimental_inline()}}</li>
+ <li>{{jsxref("Global_Objects/WeakMap", "WeakMap")}} {{experimental_inline()}}</li>
+ <li>{{jsxref("Global_Objects/WeakSet", "WeakSet")}} {{experimental_inline()}}</li>
+</ul>
+
+<h3 id="Dados_estruturados">Dados estruturados</h3>
+
+<p>Estes objetos representam e interagem com buffers de dados estruturados e dados codificados usando JavaScript Object Notation (JSON).</p>
+
+<ul>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li>{{jsxref("DataView")}}</li>
+ <li>{{jsxref("JSON")}}</li>
+</ul>
+
+<h3 id="Controle_de_abstrações_de_objetos">Controle de abstrações de objetos</h3>
+
+<ul>
+ <li>{{jsxref("Promise")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Generator")}} {{experimental_inline}}</li>
+ <li>{{jsxref("GeneratorFunction")}} {{experimental_inline}}</li>
+</ul>
+
+<h3 id="Reflexão_(reflection)">Reflexão (reflection)</h3>
+
+<ul>
+ <li>{{jsxref("Reflect")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Proxy")}} {{experimental_inline}}</li>
+</ul>
+
+<h3 id="Internacionalização">Internacionalização</h3>
+
+<p>Adições ao core do ECMAScript para funcionalidades sensíveis à linguagem.</p>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Intl", "Intl")}}</li>
+ <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li>
+ <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+ <li>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</li>
+</ul>
+
+<h3 id="Objetos_não-padrão" style="font-size: 1.71428571428571rem;">Objetos não-padrão</h3>
+
+<ul>
+ <li>{{jsxref("Iterator")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("ParallelArray")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("StopIteration")}} {{non-standard_inline}}</li>
+</ul>
+
+<h3 id="Outros">Outros</h3>
+
+<ul>
+ <li><code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a></code></li>
+</ul>
+</div>
+
+<p> </p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/infinity/index.html b/files/pt-br/web/javascript/reference/global_objects/infinity/index.html
new file mode 100644
index 0000000000..71831a3f35
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/infinity/index.html
@@ -0,0 +1,114 @@
+---
+title: Infinity
+slug: Web/JavaScript/Reference/Global_Objects/Infinity
+translation_of: Web/JavaScript/Reference/Global_Objects/Infinity
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A propriedade global <code><strong>Infinity</strong></code> é um valor numérico que representa infinito.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Infinity </code></pre>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><code>Infinity</code> é uma propriedade do <em>objeto global</em>, ou seja, é uma varíavel no escopo global.</p>
+
+<p>O valor inicial de <code>Infinity</code> é {{jsxref("Number.POSITIVE_INFINITY")}}. O valor <code>Infinity</code> (positivo) é maior do que qualquer outro número. Este valor se comporta matematicamente como infinito; por exemplo, qualquer número positivo multiplicado por <code>Infinity</code> é <code>Infinity</code>, e qualquer coisa dividida por <code>Infinity</code> é 0.</p>
+
+<p>Pela especificação ECMAScript 5, <code>Infinity</code> é somente leitura (implementado no JavaScript 1.8.5  / Firefox 4).</p>
+
+<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>ECMAScript 1ª Edição.</td>
+   <td>Padrão</td>
+   <td>Definição inicial. Implementado no JavaScript 1.3</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.1.2', 'Infinity')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
+ <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/int16array/index.html b/files/pt-br/web/javascript/reference/global_objects/int16array/index.html
new file mode 100644
index 0000000000..a989e5be3e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/int16array/index.html
@@ -0,0 +1,208 @@
+---
+title: Int16Array
+slug: Web/JavaScript/Reference/Global_Objects/Int16Array
+tags:
+  - Construtor
+  - JavaScript
+  - TypedArray
+  - TypedArrays
+translation_of: Web/JavaScript/Reference/Global_Objects/Int16Array
+---
+<div>{{JSRef}}</div>
+
+<p> </p>
+
+<p>A matriz do tipo <strong><code>Int16Array</code></strong> representa uma matriz de inteiros assinados de 16 bits com dois complementos na ordem de bytes da plataforma. Se o controle sobre a ordem de bytes for necessário, use {{jsxref ("DataView")}}. O conteúdo é inicializado em 0. Uma vez estabelecido, você pode fazer referência a elementos na matriz usando os métodos do objeto ou usando a sintaxe de índice da matriz padrão (ou seja, usando a notação de colchetes).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">new Int16Array(); // novo no ES2017
+new Int16Array(length);
+new Int16Array(typedArray);
+new Int16Array(object);
+new Int16Array(buffer [, byteOffset [, length]]);</pre>
+
+<p> </p>
+
+<p>Para obter mais informações sobre a sintaxe do construtor e os parâmetros, consulte <em><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#Syntax">TypedArray</a></em>.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT", "Int16Array.BYTES_PER_ELEMENT")}}</dt>
+ <dd>Retorna um valor numérico do tamanho do elemento. <code>2</code> no caso de um <code>Int16Array</code>.</dd>
+ <dt>Int16Array.length</dt>
+ <dd>Propriedade de comprimento estático cujo valor é 0. Para o comprimento real (número de elementos), consulte {{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}}.</dd>
+ <dt>{{jsxref("TypedArray.name", "Int16Array.name")}}</dt>
+ <dd>Retorna o valor da string do nome do construtor. No caso do tipo <code>Int16Array</code>: "Int16Array".</dd>
+ <dt>{{jsxref("TypedArray.prototype", "Int16Array.prototype")}}</dt>
+ <dd>Protótipo para os objetos TypedArray.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.from", "Int16Array.from()")}}</dt>
+ <dd>Cria um novo <code>Int16Array</code> de um objeto semelhante a uma matriz ou iterável. Veja também {{jsxref("Array.from()")}}.</dd>
+ <dt>{{jsxref("TypedArray.of", "Int16Array.of()")}}</dt>
+ <dd>Cria um novo <code>Int16Array</code> com um número variável de argumentos. Veja também {{jsxref("Array.of()")}}.</dd>
+</dl>
+
+<h2 id="Int16Array_prototype"><code>Int16Array</code> prototype</h2>
+
+<p>Todos <code>Int16Array</code> objetos herdam de {{jsxref("TypedArray.prototype", "%TypedArray%.prototype")}}.</p>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<dl>
+ <dt><code>Int16Array.prototype.constructor</code></dt>
+ <dd>Retorna a função que criou o protótipo de uma instância. Este é o construtor <code>Int16Array</code> por padrão.</dd>
+ <dt>{{jsxref("TypedArray.prototype.buffer", "Int16Array.prototype.buffer")}} {{readonlyInline}}</dt>
+ <dd>Retorna o {{jsxref("ArrayBuffer")}} referenciado pelo <code>Int16Array</code> Fixado em tempo de construção e <strong>apenas leitura</strong>.</dd>
+ <dt>{{jsxref("TypedArray.prototype.byteLength", "Int16Array.prototype.byteLength")}} {{readonlyInline}}</dt>
+ <dd>Retorna o tamanho (em bytes) de um <code>Int16Array</code> desde o ínicio {{jsxref("ArrayBuffer")}}. Fixado em tempo de construção e <strong>apenas leitura</strong>.</dd>
+ <dt>{{jsxref("TypedArray.prototype.byteOffset", "Int16Array.prototype.byteOffset")}} {{readonlyInline}}</dt>
+ <dd>Retorna o deslocamento (em bytes) de um <code>Int16Array</code> desde o ínicio {{jsxref("ArrayBuffer")}}. Fixado em tempo de construção e <strong>apenas leitura</strong>.</dd>
+ <dt>{{jsxref("TypedArray.prototype.length", "Int16Array.prototype.length")}} {{readonlyInline}}</dt>
+ <dd>Retorna o número de elementos em um <code>Int16Array</code>. Fixado em tempo de construção e <strong>apenas leitura</strong>.</dd>
+</dl>
+
+<h3 id="Métodos_2">Métodos</h3>
+
+<dl>
+ <dt>{{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}</dt>
+ <dd>Copia uma sequência de elementos da matriz dentro da matriz. Veja também {{jsxref("Array.prototype.copyWithin()")}}.</dd>
+ <dt>{{jsxref("TypedArray.entries", "Int16Array.prototype.entries()")}}</dt>
+ <dd>Retorna um novo <code>Array Iterator</code> objeto que contém os pares de chave / valor para cada índice na matriz. Veja também {{jsxref("Array.prototype.entries()")}}.</dd>
+ <dt>{{jsxref("TypedArray.every", "Int16Array.prototype.every()")}}</dt>
+ <dd>Testa se todos os elementos na matriz passam no teste fornecido por uma função. Veja também {{jsxref("Array.prototype.every()")}}.</dd>
+ <dt>{{jsxref("TypedArray.fill", "Int16Array.prototype.fill()")}}</dt>
+ <dd>Preenche todos os elementos de uma matriz de um índice inicial para um índice final com um valor estático. Veja também {{jsxref("Array.prototype.fill()")}}.</dd>
+ <dt>{{jsxref("TypedArray.filter", "Int16Array.prototype.filter()")}}</dt>
+ <dd>Cria uma nova matriz com todos os elementos dessa matriz para os quais a função de filtragem fornecida retorna true. Veja também {{jsxref("Array.prototype.filter()")}}.</dd>
+ <dt>{{jsxref("TypedArray.find", "Int16Array.prototype.find()")}}</dt>
+ <dd>Retorna o valor encontrado na matriz, se um elemento na matriz satisfizer a função de teste fornecida ou <code>undefined</code> se não encontrado. Veja também {{jsxref("Array.prototype.find()")}}.</dd>
+ <dt>{{jsxref("TypedArray.findIndex", "Int16Array.prototype.findIndex()")}}</dt>
+ <dd>Retorna o índice encontrado na matriz, se um elemento na matriz satisfizer a função de teste fornecida ou -1, se não for encontrado. Veja também {{jsxref("Array.prototype.findIndex()")}}.</dd>
+ <dt>{{jsxref("TypedArray.forEach", "Int16Array.prototype.forEach()")}}</dt>
+ <dd>Chama uma função para cada elemento na matriz. Veja também {{jsxref("Array.prototype.forEach()")}}.</dd>
+ <dt>{{jsxref("TypedArray.includes", "Int16Array.prototype.includes()")}} {{experimental_inline}}</dt>
+ <dd>Determina se uma matriz tipificada inclui um determinado elemento, retornando <code>true</code> ou <code>false</code>. Veja também {{jsxref("Array.prototype.includes()")}}.</dd>
+ <dt>{{jsxref("TypedArray.indexOf", "Int16Array.prototype.indexOf()")}}</dt>
+ <dd>Retorna o primeiro (menos) índice de um elemento dentro da matriz igual ao valor especificado ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.indexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.join", "Int16Array.prototype.join()")}}</dt>
+ <dd>Junta todos os elementos de um array em uma string. Veja também {{jsxref("Array.prototype.join()")}}.</dd>
+ <dt>{{jsxref("TypedArray.keys", "Int16Array.prototype.keys()")}}</dt>
+ <dd>Retorna um novo <code>Array Iterator</code> que contém uma chave para cada índice no array. Veja também {{jsxref("Array.prototype.keys()")}}.</dd>
+ <dt>{{jsxref("TypedArray.lastIndexOf", "Int16Array.prototype.lastIndexOf()")}}</dt>
+ <dd>Retorna o último (maior) índice de um elemento dentro da matriz igual ao valor especificado ou -1 se nenhum for encontrado. Veja também {{jsxref("Array.prototype.lastIndexOf()")}}.</dd>
+ <dt>{{jsxref("TypedArray.map", "Int16Array.prototype.map()")}}</dt>
+ <dd>Cria uma nova matriz com os resultados da chamada de uma função fornecida em todos os elementos dessa matriz. Veja também {{jsxref("Array.prototype.map()")}}.</dd>
+ <dt>{{jsxref("TypedArray.move", "Int16Array.prototype.move()")}} {{non-standard_inline}} {{unimplemented_inline}}</dt>
+ <dd>Versão não-padrão anterior de {{jsxref("TypedArray.copyWithin", "Int16Array.prototype.copyWithin()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reduce", "Int16Array.prototype.reduce()")}}</dt>
+ <dd>Aplique uma função contra um acumulador e cada valor da matriz (da esquerda para a direita) para reduzi-lo a um único valor. Veja também {{jsxref("Array.prototype.reduce()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reduceRight", "Int16Array.prototype.reduceRight()")}}</dt>
+ <dd>Aplique uma função contra um acumulador e cada valor da matriz (da direita para a esquerda) para reduzi-lo a um único valor. Veja também {{jsxref("Array.prototype.reduceRight()")}}.</dd>
+ <dt>{{jsxref("TypedArray.reverse", "Int16Array.prototype.reverse()")}}</dt>
+ <dd>Inverte a ordem dos elementos de um array - o primeiro torna-se o último e o último torna-se o primeiro. Veja também {{jsxref("Array.prototype.reverse()")}}.</dd>
+ <dt>{{jsxref("TypedArray.set", "Int16Array.prototype.set()")}}</dt>
+ <dd>Armazena vários valores na matriz tipada, lendo valores de entrada de uma matriz especificada.</dd>
+ <dt>{{jsxref("TypedArray.slice", "Int16Array.prototype.slice()")}}</dt>
+ <dd>Extrai uma seção de uma matriz e retorna uma nova matriz. Veja também {{jsxref("Array.prototype.slice()")}}.</dd>
+ <dt>{{jsxref("TypedArray.some", "Int16Array.prototype.some()")}}</dt>
+ <dd>Retorna true se pelo menos um elemento nessa matriz satisfizer a função de teste fornecida. Veja também {{jsxref("Array.prototype.some()")}}.</dd>
+ <dt>{{jsxref("TypedArray.sort", "Int16Array.prototype.sort()")}}</dt>
+ <dd>Classifica os elementos de uma matriz e retorna a matriz. Veja também {{jsxref("Array.prototype.sort()")}}.</dd>
+ <dt>{{jsxref("TypedArray.subarray", "Int16Array.prototype.subarray()")}}</dt>
+ <dd>Retorna um novo <code>Int16Array </code>a partir do índice de elemento inicial e final fornecido.</dd>
+ <dt>{{jsxref("TypedArray.values", "Int16Array.prototype.values()")}}</dt>
+ <dd>Retorna um novo objeto  <code>Array Iterator</code> que contém os valores para cada índice na matriz. Veja também {{jsxref("Array.prototype.values()")}}.</dd>
+ <dt>{{jsxref("TypedArray.toLocaleString", "Int16Array.prototype.toLocaleString()")}}</dt>
+ <dd>Retorna uma string localizada representando a matriz e seus elementos. Veja também {{jsxref("Array.prototype.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.toString", "Int16Array.prototype.toString()")}}</dt>
+ <dd>Retorna uma string representando a matriz e seus elementos. Veja também {{jsxref("Array.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("TypedArray.@@iterator", "Int16Array.prototype[@@iterator]()")}}</dt>
+ <dd>Retorna um novo objeto <code>Array Iterator</code> que contém os valores para cada índice na lista.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Diferentes opções de criar um <code>Int16Array</code>:</p>
+
+<pre class="brush: js">// De um tamanho
+var int16 = new Int16Array(2);
+int16[0] = 42;
+console.log(int16[0]); // 42
+console.log(int16.length); // 2
+console.log(int16.BYTES_PER_ELEMENT); // 2
+
+// De uma array
+var arr = new Int16Array([21,31]);
+console.log(arr[1]); // 31
+
+// De um outro TypedArray
+var x = new Int16Array([21, 31]);
+var y = new Int16Array(x);
+console.log(y[0]); // 21
+
+// De um ArrayBuffer
+var buffer = new ArrayBuffer(8);
+var z = new Int16Array(buffer, 0, 4);
+
+// De um interável
+var iterable = function*(){ yield* [1,2,3]; }();
+var int16 = new Int16Array(iterable);
+// Int16Array[1, 2, 3]
+</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('Typed Array')}}</td>
+   <td>{{Spec2('Typed Array')}}</td>
+   <td>Substituído pelo ECMAScript 2015.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#table-49', 'TypedArray constructors')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial em um padrão ECMA. Especificado <code>new</code> como requerido.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#table-49', 'TypedArray constructors')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>ECMAScript 2017 mudou o construtor <code>Int16Array</code> para usar a operação <code>ToIndex</code> e permitir construtores sem argumentos.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Int16Array")}}</p>
+
+<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
+
+<p>A partir do ECMAScript 2015, os construtores <code>Int16Array</code> precisam ser construídos com um operador {{jsxref("Operators/new", "new")}}. Chamar um construtor <code>Int16Array</code> como uma função sem o <code>new</code>, irá resultar em {{jsxref("TypeError")}}.</p>
+
+<pre class="brush: js example-bad">var dv = Int16Array([1, 2, 3]);
+// TypeError: calling a builtin Int16Array constructor
+// without new is forbidden</pre>
+
+<pre class="brush: js example-good">var dv = new Int16Array([1, 2, 3]);</pre>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li>{{jsxref("DataView")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/internalerror/index.html b/files/pt-br/web/javascript/reference/global_objects/internalerror/index.html
new file mode 100644
index 0000000000..12de103329
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/internalerror/index.html
@@ -0,0 +1,92 @@
+---
+title: InternalError
+slug: Web/JavaScript/Reference/Global_Objects/InternalError
+translation_of: Web/JavaScript/Reference/Global_Objects/InternalError
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O <strong>objeto</strong> <strong><code>InternalError</code> </strong>indica que um erro ocorreu internamente na engine do JavaScript.</p>
+
+<p>Isso ocorre quando algo é muito grande, por exemplo:</p>
+
+<ul>
+ <li>"too many switch cases",</li>
+ <li>"too many parentheses in regular expression",</li>
+ <li>"array initializer too large",</li>
+ <li>"too much recursion".</li>
+</ul>
+
+<h2 id="Construtor">Construtor</h2>
+
+<dl>
+ <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/InternalError/InternalError"><code>InternalError()</code></a></dt>
+ <dd>Cria um um novo objeto <code>InternalError</code>.</dd>
+</dl>
+
+<h2 id="Instance_properties">Instance properties</h2>
+
+<dl>
+ <dt>{{jsxref("Error.prototype.message", "InternalError.prototype.message")}}</dt>
+ <dd>Error message. Inherited from {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.name", "InternalError.prototype.name")}}</dt>
+ <dd>Error name. Inherited from {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.fileName", "InternalError.prototype.fileName")}}</dt>
+ <dd>Path to file that raised this error. Inherited from {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.lineNumber", "InternalError.prototype.lineNumber")}}</dt>
+ <dd>Line number in file that raised this error. Inherited from {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.columnNumber", "InternalError.prototype.columnNumber")}}</dt>
+ <dd>Column number in line that raised this error. Inherited from {{jsxref("Error")}}.</dd>
+ <dt>{{jsxref("Error.prototype.stack", "InternalError.prototype.stack")}}</dt>
+ <dd>Stack trace. Inherited from {{jsxref("Error")}}.</dd>
+</dl>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Too_much_recursion">Too much recursion</h3>
+
+<p>This recursive function runs 10 times, as per the exit condition.</p>
+
+<pre class="brush: js notranslate">function loop(x) {
+  if (x &gt;= 10) // "x &gt;= 10" is the exit condition
+    return;
+  // do stuff
+  loop(x + 1); // the recursive call
+}
+loop(0);</pre>
+
+<p>Setting this condition to an extremely high value, won't work:</p>
+
+<pre class="brush: js example-bad notranslate">function loop(x) {
+  if (x &gt;= 1000000000000)
+    return;
+  // do stuff
+  loop(x + 1);
+}
+loop(0);
+
+// InternalError: too much recursion</pre>
+
+<p>For more information, see <a href="/en-US/docs/Web/JavaScript/Reference/Errors/Too_much_recursion">InternalError: too much recursion.</a></p>
+
+<h2 id="Specifications">Specifications</h2>
+
+<p><span class="pl-s">Not part of any standard.</span></p>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.InternalError")}}</p>
+</div>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Error")}}</li>
+ <li>
+  <p><a href="/en-US/docs/Web/JavaScript/Reference/Errors/Too_much_recursion">InternalError: too much recursion</a></p>
+ </li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/datetimeformat/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/datetimeformat/index.html
new file mode 100644
index 0000000000..6c060cd838
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/intl/datetimeformat/index.html
@@ -0,0 +1,188 @@
+---
+title: Intl.DateTimeFormat
+slug: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/DateTimeFormat
+---
+<div>{{JSRef}}</div>
+
+<p><span class="seoSummary">O objeto Intl.DateTimeFormat é um constructor para objetos que habilita o formato de data e hora no idioma padrão.</span> </p>
+
+<div>{{EmbedInteractiveExample("pages/js/intl-datetimeformat.html")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<h2 id="Constructor">Constructor</h2>
+
+<dl>
+ <dt><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/DateTimeFormat/DateTimeFormat">Intl.DateTimeFormat()</a></code></dt>
+ <dd>Creates a new <code>DateTimeFormat</code> object.</dd>
+</dl>
+
+<h2 id="Static_methods">Static methods</h2>
+
+<dl>
+ <dt>{{jsxref("DateTimeFormat.supportedLocalesOf", "Intl.DateTimeFormat.supportedLocalesOf()")}}</dt>
+ <dd>Returns an array containing those of the provided locales that are supported without having to fall back to the runtime's default locale.</dd>
+</dl>
+
+<h2 id="Instance_methods">Instance methods</h2>
+
+<dl>
+ <dt>{{jsxref("DateTimeFormat.format", "Intl.DateTimeFormat.prototype.format()")}}</dt>
+ <dd>Getter function that formats a date according to the locale and formatting options of this {{jsxref("DateTimeFormat", "DateTimeFormat")}} object.</dd>
+ <dt>{{jsxref("DateTimeFormat.formatToParts", "Intl.DateTimeFormat.prototype.formatToParts()")}}</dt>
+ <dd>Returns an {{jsxref("Array")}} of objects representing the date string in parts that can be used for custom locale-aware formatting.</dd>
+ <dt>{{jsxref("DateTimeFormat.resolvedOptions", "Intl.DateTimeFormat.prototype.resolvedOptions()")}}</dt>
+ <dd>Returns a new object with properties reflecting the locale and formatting options computed during initialization of the object.</dd>
+ <dt>{{jsxref("DateTimeFormat.formatRange", "Intl.DateTimeFormat.prototype.formatRange()")}}</dt>
+ <dd>This method receives two <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/">Dates</a> and formats the date range in the most concise way based on the locale and options provided when instantiating {{jsxref("DateTimeFormat", "DateTimeFormat")}}.</dd>
+ <dt>{{jsxref("DateTimeFormat.formatRangeToParts", "Intl.DateTimeFormat.prototype.formatRangeToParts()")}}</dt>
+ <dd>This method receives two <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/">Dates</a> and returns an Array of objects containing the locale-specific tokens representing each part of the formatted date range.</dd>
+</dl>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_DateTimeFormat">Using <code>DateTimeFormat</code></h3>
+
+<p>In basic use without specifying a locale, <code>DateTimeFormat</code> uses the default locale and default options.</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// toLocaleString without arguments depends on the implementation,
+// the default locale, and the default time zone
+console.log(new Intl.DateTimeFormat().format(date));
+// → "12/19/2012" if run with en-US locale (language) and time zone America/Los_Angeles (UTC-0800)
+</pre>
+
+<h3 id="Using_locales">Using <code>locales</code></h3>
+
+<p>This example shows some of the variations in localized date and time formats. In order to get the format of the language used in the user interface of your application, make sure to specify that language (and possibly some fallback languages) using the <code>locales</code> argument:</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0));
+
+// Results below use the time zone of America/Los_Angeles (UTC-0800, Pacific Standard Time)
+
+// US English uses month-day-year order
+console.log(new Intl.DateTimeFormat('en-US').format(date));
+// → "12/19/2012"
+
+// British English uses day-month-year order
+console.log(new Intl.DateTimeFormat('en-GB').format(date));
+// → "19/12/2012"
+
+// Korean uses year-month-day order
+console.log(new Intl.DateTimeFormat('ko-KR').format(date));
+// → "2012. 12. 19."
+
+// Arabic in most Arabic speaking countries uses real Arabic digits
+console.log(new Intl.DateTimeFormat('ar-EG').format(date));
+// → "١٩<span dir="rtl">‏/١٢‏/٢٠١٢</span>"
+
+// for Japanese, applications may want to use the Japanese calendar,
+// where 2012 was the year 24 of the Heisei era
+console.log(new Intl.DateTimeFormat('ja-JP-u-ca-japanese').format(date));
+// → "24/12/19"
+
+// when requesting a language that may not be supported, such as
+// Balinese, include a fallback language, in this case Indonesian
+console.log(new Intl.DateTimeFormat(['ban', 'id']).format(date));
+// → "19/12/2012"
+</pre>
+
+<h3 id="Using_options">Using <code>options</code></h3>
+
+<p>The date and time formats can be customized using the <code>options</code> argument:</p>
+
+<pre class="brush: js">var date = new Date(Date.UTC(2012, 11, 20, 3, 0, 0, 200));
+
+// request a weekday along with a long date
+var options = { weekday: 'long', year: 'numeric', month: 'long', day: 'numeric' };
+console.log(new Intl.DateTimeFormat('de-DE', options).format(date));
+// → "Donnerstag, 20. Dezember 2012"
+
+// an application may want to use UTC and make that visible
+options.timeZone = 'UTC';
+options.timeZoneName = 'short';
+console.log(new Intl.DateTimeFormat('en-US', options).format(date));
+// → "Thursday, December 20, 2012, GMT"
+
+// sometimes you want to be more precise
+options = {
+  hour: 'numeric', minute: 'numeric', second: 'numeric',
+  timeZone: 'Australia/Sydney',
+  timeZoneName: 'short'
+};
+console.log(new Intl.DateTimeFormat('en-AU', options).format(date));
+// → "2:00:00 pm AEDT"
+
+// sometimes you want to be very precise
+options.fractionalSecondDigits = 3;
+console.log(new Intl.DateTimeFormat('en-AU', options).format(date));
+// → "2:00:00.200 pm AEDT"
+
+
+// sometimes even the US needs 24-hour time
+options = {
+  year: 'numeric', month: 'numeric', day: 'numeric',
+  hour: 'numeric', minute: 'numeric', second: 'numeric',
+  hour12: false,
+  timeZone: 'America/Los_Angeles'
+};
+console.log(new Intl.DateTimeFormat('en-US', options).format(date));
+// → "12/19/2012, 19:00:00"
+
+
+// to specify options but use the browser's default locale, use 'default'
+console.log(new Intl.DateTimeFormat('default', options).format(date));
+// → "12/19/2012, 19:00:00"
+
+// sometimes it's helpful to include the period of the day
+options = {hour: "numeric", dayPeriod: "short"};
+console.log(new Intl.DateTimeFormat('en-US', options).format(date));
+// → 10 at night
+</pre>
+
+<p>The used calendar and numbering formats can also be set independently via <code>options</code> arguments:</p>
+
+<pre class="brush: js">var options = {calendar: 'chinese', numberingSystem: 'arab'};
+var dateFormat = new Intl.DateTimeFormat('default', options);
+var usedOptions = dateFormat.resolvedOptions();
+
+console.log(usedOptions.calendar);
+// → "chinese"
+
+console.log(usedOptions.numberingSystem);
+// → "arab"
+
+console.log(usedOptions.timeZone);
+// → "America/New_York" (the users default timezone)
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#datetimeformat-objects', 'Intl.DateTimeFormat')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Intl.DateTimeFormat")}}</p>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl">Intl</a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/index.html
new file mode 100644
index 0000000000..02e5b8f205
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/intl/index.html
@@ -0,0 +1,168 @@
+---
+title: Intl
+slug: Web/JavaScript/Reference/Global_Objects/Intl
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl
+---
+<div>{{JSRef}}</div>
+
+<p>O objeto <strong><code>Intl</code></strong> é o namespace para a API de Internacionalização do ECMAScript , que fornece comparação de string sensível à línguagem, formatação de números, e formatação de data e hora. Os construtores para os objetos {{jsxref("Collator")}}, {{jsxref("NumberFormat")}}, e {{jsxref("DateTimeFormat")}} são propriedades do objecto <code>Intl</code>. Esta página documenta essas propriedades, bem como funcionalidades comuns aos construtores de internacionalização e outras funções sensíveis de linguagem.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</dt>
+ <dd>Construtor para <em>collators</em>, objetos que permitem comparação de string sensível a linguagem.</dd>
+ <dt>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</dt>
+ <dd>Construtor para objetos que permitem formatação de data e hora sensível a linguagem.</dd>
+ <dt>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</dt>
+ <dd>Construtor para objetos que permitem formatação de número sensível a linguagem.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Intl.getCanonicalLocales()")}}</dt>
+ <dd>Retorna os nomes canônicos de local (ex.: en-US, pt-BR).</dd>
+</dl>
+
+<h2 id="Identificação_e_negociação_de_local">Identificação e negociação de local</h2>
+
+<p>Os construtores de internacionalização, assim como diversos métodos de outros construtores que são sensíveis a idioma (listados em {{anch("See_also", "Veja também")}}) usam um padrão comum para identificar locais e determinar qual será utilizado: todos aceitam argumentos <code>locales</code> e <code>options</code> e negociam o(s) local(is) requisitado entre os locais suportados usando um algoritmo especificado na propriedade <code>options.localeMatcher</code>.</p>
+
+<h3 id="Argumento_locales">Argumento <code>locales</code></h3>
+
+<p>O argumento <code>locales</code> deve ser uma string contendo uma <a href="http://tools.ietf.org/html/rfc5646">tag de linguagem BCP 47</a> ou um array dessas tags. Se o argumento <code>locales</code> não for passado ou estiver indefinido, será utilizado o local padrão do runtime.</p>
+
+<p>Uma tag de linguagem BCP 47 identifica um idioma ou local (a diferença entre ambos neste caso é difusa). Em sua forma mais comum, ela pode conter, nesta ordem: um código de idioma, um código de escrita e um código de país, todos eparados por hífen. Exemplos:</p>
+
+<ul>
+ <li><code>"hi"</code>: Hindi.</li>
+ <li><code>"de-AT"</code>: Alemão como usado na Áustria.</li>
+ <li><code>"zh-Hans-CN"</code>: Chinês com escrita simplificada como usado na China.</li>
+</ul>
+
+<p>As subtags identificando idiomas, escritas, países (regiões) e (raramente utilizadas) variantes nas tags de linguagem BCP 47 podem ser consultadas no <a href="http://www.iana.org/assignments/language-subtag-registry">Registro de Subtags de Linguagem da IANA</a>.</p>
+
+<p>BCP 47 também permite extensões, e uma delas é relevante para as funções JavaScript de internacionalização: a extensão <code>"u"</code> (Unicode). Ela pode ser utilizada para requisitar uma customização do comportamento específico local de um objeto {{jsxref("Collator")}}, {{jsxref("NumberFormat")}}, ou {{jsxref("DateTimeFormat")}}. Exemplos:</p>
+
+<ul>
+ <li><code>"de-DE-u-co-phonebk"</code>: Use the phonebook variant of the German sort order, which expands umlauted vowels to character pairs: ä → ae, ö → oe, ü → ue.</li>
+ <li><code>"th-TH-u-nu-thai"</code>: Use Thai digits (๐, ๑, ๒, ๓, ๔, ๕, ๖, ๗, ๘, ๙) in number formatting.</li>
+ <li><code>"ja-JP-u-ca-japanese"</code>: Use the Japanese calendar in date and time formatting, so that 2013 is expressed as the year 25 of the Heisei period, or 平成25.</li>
+</ul>
+
+<h3 id="Locale_negotiation">Locale negotiation</h3>
+
+<p>The <code>locales</code> argument, after stripping off all Unicode extensions, is interpreted as a prioritized request from the application. The runtime compares it against the locales it has available and picks the best one available. Two matching algorithms exist: the <code>"lookup"</code> matcher follows the Lookup algorithm specified in <a href="http://tools.ietf.org/html/rfc4647#section-3.4">BCP 47</a>; the <code>"best fit"</code> matcher lets the runtime provide a locale that's at least, but possibly more, suited for the request than the result of the Lookup algorithm. If the application doesn't provide a <code>locales</code> argument, or the runtime doesn't have a locale that matches the request, then the runtime's default locale is used. The matcher can be selected using a property of the <code>options</code> argument (see below).</p>
+
+<p>If the selected language tag had a Unicode extension substring, that extension is now used to customize the constructed object or the behavior of the function. Each constructor or function supports only a subset of the keys defined for the Unicode extension, and the supported values often depend on the language tag. For example, the <code>"co"</code> key (collation) is only supported by {{jsxref("Collator")}}, and its <code>"phonebk"</code> value is only supported for German.</p>
+
+<h3 id="options_argument"><code>options</code> argument</h3>
+
+<p>The <code>options</code> argument must be an object with properties that vary between constructors and functions. If the <code>options</code> argument is not provided or is undefined, default values are used for all properties.</p>
+
+<p>One property is supported by all language sensitive constructors and functions: The <code>localeMatcher</code> property, whose value must be a string <code>"lookup"</code> or <code>"best fit"</code> and which selects one of the locale matching algorithms described above.</p>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES Int 1.0', '#sec-8', 'Intl')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-8', 'Intl')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#intl-object', 'Intl')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td>Added Intl.getCanonicalLocales in the 4th edition.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("24")}}</td>
+   <td>{{CompatGeckoDesktop("29")}}</td>
+   <td>{{CompatIE("11")}}</td>
+   <td>{{CompatOpera("15")}}</td>
+   <td>{{CompatSafari("10.0")}} [2]</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Phone</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("26")}}</td>
+   <td>{{CompatGeckoMobile("54")}} (nightly-only) [1]</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatSafari("10.0")}} [2]</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Starting with Gecko 44 {{geckoRelease(44)}}, the Intl API is available on <a href="https://people.mozilla.org/~fdesre/b2gdroid/">b2gdroid</a>.<br>
+ [2] <a href="https://developer.apple.com/library/content/releasenotes/General/WhatsNewInSafari/Articles/Safari_10_0.html">Safari 10.0 Release Notes</a></p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>Introduction: <a href="http://norbertlindenberg.com/2012/12/ecmascript-internationalization-api/index.html">The ECMAScript Internationalization API</a></li>
+ <li>Constructors
+  <ul>
+   <li>{{jsxref("Collator", "Intl.Collator")}}</li>
+   <li>{{jsxref("DateTimeFormat", "Intl.DateTimeFormat")}}</li>
+   <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
+  </ul>
+ </li>
+ <li>Methods
+  <ul>
+   <li>{{jsxref("String.prototype.localeCompare()")}}</li>
+   <li>{{jsxref("Number.prototype.toLocaleString()")}}</li>
+   <li>{{jsxref("Date.prototype.toLocaleString()")}}</li>
+   <li>{{jsxref("Date.prototype.toLocaleDateString()")}}</li>
+   <li>{{jsxref("Date.prototype.toLocaleTimeString()")}}</li>
+  </ul>
+ </li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/index.html
new file mode 100644
index 0000000000..ac698fd883
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/index.html
@@ -0,0 +1,242 @@
+---
+title: Intl.NumberFormat
+slug: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+tags:
+  - Internacionalização
+  - JavaScript
+  - NumberFormat
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+---
+<h5 id="JSRef">{{JSRef}}</h5>
+
+<p>O objeto <strong><code>Intl.NumberFormat</code></strong> é um construtor para objetos que habilita formatação de número sensível a linguagem.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/intl-numberformat.html")}}</p>
+
+<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>new Intl.NumberFormat([<var>locales</var>[, <var>options</var>]])
+Intl.NumberFormat.call(<var>this</var>[, <var>locales</var>[, <var>options</var>]])
+</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>locales</code></dt>
+ <dd>
+ <p>Opcional. Uma string com uma tag de linguagem BCP 47 ou uma matriz delas. Para a forma geral e interpretação do argumento <code>locales</code>, veja {{jsxref("Intl", "Intl page", "#Locale_identification_and_negotiation", 1)}}. A seguinte chave extendida Unicode é permitida:</p>
+
+ <dl>
+  <dt><code>nu</code></dt>
+  <dd>O sistema de numeração que será usado. Os valores permitidos são: <code>"arab"</code>, <code>"arabext"</code>, <code>"bali"</code>, <code>"beng"</code>, <code>"deva"</code>, <code>"fullwide"</code>, <code>"gujr"</code>, <code>"guru"</code>, <code>"hanidec"</code>, <code>"khmr"</code>, <code>"knda"</code>, <code>"laoo"</code>, <code>"latn"</code>, <code>"limb"</code>, <code>"mlym"</code>, <code>"mong"</code>, <code>"mymr"</code>, <code>"orya"</code>, <code>"tamldec"</code>, <code>"telu"</code>, <code>"thai"</code>, <code>"tibt"</code>.</dd>
+ </dl>
+ </dd>
+ <dt><code>options</code></dt>
+ <dd>
+ <p>Opcional. Um objeto com alguns ou todas as seguintes propriedades:</p>
+
+ <dl>
+  <dt><code>localeMatcher</code></dt>
+  <dd>O algoritmo de comparação de localização para utilizar. Os valores permitidos são <code>"lookup"</code> e <code>"best fit"</code>; o padrão é <code>"best fit"</code>. Para mais informações sobre esta opção, veja  {{jsxref("Global_Objects/Intl", "Intl page", "#Locale_negotiation", 1)}}.</dd>
+  <dt><code>style</code></dt>
+  <dd>O estilo do formato a ser utilizado. Os valores permitidos são <code>"decimal"</code> para formato de número simples, <code>"currency"</code> para formato monetário e <code>"percent"</code> para formato percentual; o padrão é <code>"decimal"</code>.</dd>
+  <dt><code>currency</code></dt>
+  <dd>A moeda para usar na formatação monetária. Os valores permitidos são os códigos de moedas da ISO 4217, como <code>"USD"</code> para dólar estadunidense, <code>"EUR"</code> para euro, ou <code>"CNY"</code> para RMB chinês — veja a <a href="http://www.currency-iso.org/en/home/tables/table-a1.html">Lista de códigos de moedas e fundos atuais</a>. Não há valor padrão; se o <code>style</code> for <code>"currency"</code>, a propriedade <code>currency</code> deverá ser informada.</dd>
+  <dt><code>currencyDisplay</code></dt>
+  <dd>Como será mostrada a moeda na formatação monetária. Os valores permitidos são<code> "symbol"</code> para usar um símbolo de moeda localizado como €, <code>"code"</code> para usar o código de moeda ISO, <code>"name"</code> para usar o nome da moeda localizado como <code>"dollar"</code>; o padrão é <code>"symbol"</code>.</dd>
+  <dt><code>useGrouping</code></dt>
+  <dd>Se usar separadores de agrupamento, como separadores de milhares ou milhares/cem mil/dez milhões. Os valores permitidos são <code>true</code> e <code>false</code>; o padrão é <code>true</code>.</dd>
+ </dl>
+
+ <p>As próximas propriedades se dividem em dois grupos: <code>minimumIntegerDigits</code>, <code>minimumFractionDigits</code>, e <code>maximumFractionDigits</code> no primeiro grupo, <code>minimumSignificantDigits</code> and <code>maximumSignificantDigits</code> em outro. Se pelo menos uma propriedade do segundo grupo for informado, então o primeiro grupo é ignorado.</p>
+
+ <dl>
+  <dt><code>minimumIntegerDigits</code></dt>
+  <dd>A quantidade mínima de dígitos inteiros para utilizar. É possível usar valores de 1 a 21; o padrão é 1.</dd>
+  <dt><code>minimumFractionDigits</code></dt>
+  <dd>A quantidade mínima de dígitos fracionados para utilizar. É possível usar valores de 0 a 20; o padrão para formatos de números simples e percentuais é 0; o padrão para formatos monetários é a menor unidade de dígitos fornecidos pela <a href="http://www.currency-iso.org/en/home/tables/table-a1.html">lista de códigos de moedas ISO 4217</a> (2 se a lista não fornecer a informação).</dd>
+  <dt><code>maximumFractionDigits</code></dt>
+  <dd>O número máximo de dígitos fracionados para utilizar. É possível usar valores de 0 a 20; o padrão para a formatação de número simples é o maior entre <code>minimumFractionDigits</code> e 3; o padrão para formatos monetários é o maior número de dígitos entre  <code>minimumFractionDigits</code> e o fornecido pela <a href="http://www.currency-iso.org/en/home/tables/table-a1.html">lista de códigos de moedas ISO 4217</a> (2 se a lista não fornecer a informação); o padrão para a formatação percentual é o maior número entre <code>minimumFractionDigits</code> e 0.</dd>
+  <dt><code>minimumSignificantDigits</code></dt>
+  <dd>A quantidade mínima de dígitos significantes para usar. Os valores permitidos são de 1 a 21; o padrão é 1.</dd>
+  <dt><code>maximumSignificantDigits</code></dt>
+  <dd>A quantidade máxima de dígitos significantes para usar. Os valores permitidos são de 1 a 21; o padrão é <code>minimumSignificantDigits</code>.</dd>
+ </dl>
+ </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<h3 id="Propriedades">Propriedades</h3>
+
+<dl>
+ <dt>{{jsxref("NumberFormat.prototype", "Intl.NumberFormat.prototype")}}</dt>
+ <dd>Pertime a inclusão de propriedades a todos os objetos.</dd>
+</dl>
+
+<h3 id="Métodos">Métodos</h3>
+
+<dl>
+ <dt>{{jsxref("NumberFormat.supportedLocalesOf", "Intl.NumberFormat.supportedLocalesOf()")}}</dt>
+ <dd>Retorna uma matriz contendo as localizações fornecidas que são suportadas sem retornar a localização padrão em tempo de execução.</dd>
+</dl>
+
+<h2 id="Instâncias_NumberFormat">Instâncias <code>NumberFormat</code></h2>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<p>As instâncias de <code>NumberFormat</code> herdam as seguntes propriedades de seu protótipo:</p>
+
+<div>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype', 'Propriedades')}}</div>
+
+<h3 id="Methods">Methods</h3>
+
+<p>As instâncias de <code>NumberFormat</code> herdam os seguintes métodos de seu protótipo:</p>
+
+<div>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat/prototype', 'Métodos')}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Uso_básico">Uso básico</h3>
+
+<p>No uso básico sem a especificação de uma localização, o método retornará uma string formatada com a localização e as opções padrão.</p>
+
+<pre class="brush: js">var numero = 3500;
+
+console.log(new Intl.NumberFormat().format(numero));
+// → '3,500' se a localização for U.S. English
+</pre>
+
+<h3 id="Usando_locales">Usando <code>locales</code></h3>
+
+<p>Este exemplo mostra algumas variações de formatos de números localizados. A fim de obter o formato da linguagem utilizada na interface do usuário da sua aplicação, tenha certeza de especificar a língua (e possivelmente algumas línguas reservas) usando o argumento<code> locales</code>:</p>
+
+<pre class="brush: js">var numero = 123456.789;
+
+// O alemão usa vírgula como separador de decimal e ponto para milhares
+console.log(new Intl.NumberFormat('de-DE').format(numero));
+// → 123.456,789
+
+// O árabe usa dígitos reais árabes em muitos países que falam árabe
+console.log(new Intl.NumberFormat('ar-EG').format(numero));
+// → ١٢٣٤٥٦٫٧٨٩
+
+// A Índia usa separadores de milhares/cem mil/dez milhões
+console.log(new Intl.NumberFormat('en-IN').format(numero));
+// → 1,23,456.789
+
+// A chave de extensão nu requer um sistema de numeração, ex. decimal chinês
+console.log(new Intl.NumberFormat('zh-Hans-CN-u-nu-hanidec').format(numero));
+// → 一二三,四五六.七八九
+
+// Quando informada uma língua sem suporte, como balinês,
+// inclua uma língua reseva, neste caso indonésio
+console.log(new Intl.NumberFormat(['ban', 'id']).format(numero));
+// → 123.456,789
+</pre>
+
+<h3 id="Usando_options">Usando <code>options</code></h3>
+
+<p>Os resultados podem ser personalizados usando o argumento <code>options</code>:</p>
+
+<pre class="brush: js">var numero = 123456.789;
+
+// informando um formato de moeda
+console.log(new Intl.NumberFormat('de-DE', { style: 'currency', currency: 'EUR' }).format(numero));
+// → 123.456,79 €
+
+// o yen japonês não tem uma unidade menor
+console.log(new Intl.NumberFormat('ja-JP', { style: 'currency', currency: 'JPY' }).format(numero));
+// → ￥123,457
+
+// limitando a três dígitos significativos
+console.log(new Intl.NumberFormat('en-IN', { maximumSignificantDigits: 3 }).format(numero));
+// → 1,23,000
+</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('ES Int 1.0', '#sec-11.1', 'Intl.NumberFormat')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-11.1', 'Intl.NumberFormat')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#numberformat-objects', 'Intl.NumberFormat')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("24")}}</td>
+   <td>{{CompatGeckoDesktop("29")}}</td>
+   <td>{{CompatIE("11")}}</td>
+   <td>{{CompatOpera("15")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Phone</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("26")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<div>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Intl', 'Veja_tambem')}}</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/prototype/index.html
new file mode 100644
index 0000000000..badd2d1946
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/intl/numberformat/prototype/index.html
@@ -0,0 +1,125 @@
+---
+title: Intl.NumberFormat.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/prototype
+tags:
+  - Internacionalização
+  - JavaScript
+  - NumberFormat
+  - Property
+  - Propriedade
+  - Prototipo
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Intl.NumberFormat.prototype</code></strong> representa o objeto do protótipo do construtor de {{jsxref("NumberFormat", "Intl.NumberFormat")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Veja {{jsxref("NumberFormat")}} para uma descrição sobre instâncias de <code>Intl.NumberFormat</code>.</p>
+
+<p>As instâncias de {{jsxref("NumberFormat", "Intl.NumberFormat")}} herdam de <code>Intl.NumberFormat.prototype</code>. Modificações ao objeto do protótipo são herdados por todas as instâncias de {{jsxref("NumberFormat", "Intl.NumberFormat")}}.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>Intl.NumberFormat.prototype.constructor</code></dt>
+ <dd>Uma referência a <code>Intl.NumberFormat</code>.</dd>
+ <dt>{{jsxref("NumberFormat.format", "Intl.NumberFormat.prototype.format")}}</dt>
+ <dd>Getter; retorna uma função que formata um número de acordo com a localização e as opçõe de formatação do objeto {{jsxref("NumberFormat")}}.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("NumberFormat.resolvedOptions", "Intl.NumberFormat.prototype.resolvedOptions()")}}</dt>
+ <dd>Retorna um novo objeto com propriedades refletindo a localização e as opções de agrupamento obtidos durante a inicialização do objeto.</dd>
+</dl>
+
+<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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 1.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-11.2.1', 'Intl.NumberFormat.prototype')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sec-Intl.NumberFormat.prototype', 'Intl.NumberFormat.prototype')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("24")}}</td>
+   <td>{{CompatGeckoDesktop("29")}}</td>
+   <td>{{CompatIE("11")}}</td>
+   <td>{{CompatOpera("15")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Phone</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("26")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("NumberFormat", "Intl.NumberFormat")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/intl/relativetimeformat/index.html b/files/pt-br/web/javascript/reference/global_objects/intl/relativetimeformat/index.html
new file mode 100644
index 0000000000..bc6b5c0b22
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/intl/relativetimeformat/index.html
@@ -0,0 +1,171 @@
+---
+title: Intl.RelativeTimeFormat
+slug: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
+tags:
+  - Internacionalização
+  - Intl
+translation_of: Web/JavaScript/Reference/Global_Objects/Intl/RelativeTimeFormat
+---
+<div>{{JSRef}}</div>
+
+<p>O objeto <strong><code>Intl.RelativeTimeFormat</code></strong> é um construtor de objetos que permitem uma formatação de tempo relativa sensível ao idioma.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/intl-relativetimeformat.html")}}</div>
+
+<p class="hidden">A fonte deste exemplo interativo está armazenada num repositório no GitHub. Se você quiser contribuir para o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre><code>new Intl.RelativeTimeFormat([<var>locales</var>[, <var>options</var>]])
+</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>locales</code></dt>
+ <dd>
+ <p>Opcional. Uma string com uma tag da linguagem BCP 47, ou um array dessas strings. Para a forma geral e interpretação do argumento <code>locales</code> , acesse: {{jsxref("Global_Objects/Intl", "Página Intl", "#Locale_identification_and_negotiation", 1)}}.</p>
+ </dd>
+ <dt><code>options</code></dt>
+ <dd>Opcional. Um objeto com algumas ou todas as seguintes propriedades:
+ <ul>
+  <li><code>localeMatcher</code><br>
+   O algoritmo para comparação de local a ser usado. Os valores possíveis são <code>"lookup"</code> e <code>"best fit"</code>; o padrão é <code>"best fit"</code>. Para informações sobre esta opção, veja <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl#Locale_negotiation" rel="nofollow"><code>Intl</code></a>.</li>
+  <li><code>numeric</code><br>
+   O formato de saída da mensagem. Valores possíveis são:
+   <ul>
+    <li><code>"always"</code> (padrão, e.g., <code>há 1 dia</code>),</li>
+    <li>ou <code>"auto"</code> (e.g., <code>ontem</code>). O valor<code>"auto"</code> permite que não seja sempre necessário o uso de valores númericos na saída.</li>
+   </ul>
+  </li>
+  <li><code>style</code><br>
+   O comprimento da mensagem internacionalizada. Valores possíveis são:
+   <ul>
+    <li><code>"long"</code> (padrão, e.g., <code>in 1 month</code>)</li>
+    <li><code>"short"</code> (e.g., <code>in 1 mo.</code>),</li>
+    <li>ou <code>"narrow"</code> (e.g., <code>in 1 mo.</code>). O estilo narrow pode ser similar ao short em alguns locais.</li>
+   </ul>
+  </li>
+ </ul>
+ </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<h3 id="Propriedades">Propriedades</h3>
+
+<dl>
+ <dt>{{jsxref("RelativeTimeFormat.prototype", "Intl.RelativeTimeFormat.prototype")}}</dt>
+ <dd>Permite a adição de propriedades para todos os objetos.</dd>
+</dl>
+
+<h3 id="Métodos">Métodos</h3>
+
+<dl>
+ <dt>{{jsxref("RelativeTimeFormat.supportedLocalesOf", "Intl.RelativeTimeFormat.supportedLocalesOf()")}}</dt>
+ <dd>Retorna um array contendo os valores disponíveis dentre os que foram passados como parâmetro sem ter de recorrer ao local padrão do ambiente.</dd>
+</dl>
+
+<h2 id="Instâncias_RelativeTimeFormat">Instâncias <code>RelativeTimeFormat</code> </h2>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<p>Instâncias <code>RelativeTimeFormat</code> herdam as seguintes propriedades do seu protótipo:</p>
+
+<p>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RelativeTimeFormat/prototype', 'Properties')}}</p>
+
+<h3 id="Métodos_2">Métodos</h3>
+
+<p>Instâncias <code>RelativeTimeFormat</code>  herdam as seguintes propriedades do seu protótipo:</p>
+
+<p>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RelativeTimeFormat/prototype', 'Methods')}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Uso_básico_do_format">Uso básico do <code>format</code></h3>
+
+<p>O exemplo a seguir mostra como criar um formatador de tempo relativo usando a língua portuguesa.</p>
+
+<pre class="brush: js">// Crie um formatador de tempo relativo no seu local
+// com os valores padrão sendo passados explicitamente.
+const rtf = new Intl.RelativeTimeFormat("pt", {
+    localeMatcher: "best fit", // outros valores: "lookup"
+    numeric: "always", // outros valores: "auto"
+    style: "long", // outros valores: "short" ou "narrow"
+});
+
+// Formatação de tempo relativa usando valor negativo (-1).
+rtf.format(-1, "day");
+// &gt; "há 1 dia"
+
+// Formatação de tempo relativa usando valor positivo (1).
+rtf.format(1, "day");
+// &gt; "em 1 dia"</pre>
+
+<h3 id="Usando_a_opção_auto">Usando a opção <code>auto</code></h3>
+
+<p>Se a opção <code>numeric:auto</code> é passada, serão produzidas as strings <code>ontem</code> ou <code>amanhã</code> ao invés de <code>há 1 dia</code> ou <code>em 1 dia</code>. Isso permite que não seja necessário sempre utilizar valores numéricos na saída.</p>
+
+<pre class="brush: js">// Crie um formatador de tempo relativo no seu local
+// com o valor "auto" passado para a propriedade numeric.
+const rtf = new Intl.RelativeTimeFormat("pt", { numeric: "auto" });
+
+// Formatação de tempo relativa usando valor negativo (-1).
+rtf.format(-1, "day");
+// &gt; "ontem"
+
+// Formatação de tempo relativa usando valor positivo (1).
+rtf.format(1, "day");
+// &gt; "amanhã"
+</pre>
+
+<h3 id="Usando_formatToParts">Usando <code>formatToParts</code></h3>
+
+<p>O exemplo a seguir mostra como criar um formatador de tempo relativo que retorna partes formatadas</p>
+
+<pre class="brush: js">const rtf = new Intl.RelativeTimeFormat("en", { numeric: "auto" });
+
+// Formatação de tempo relativa usando a unidade day.
+rtf.formatToParts(-1, "day");
+// &gt; [{type: "literal", value: "ontem"}]
+
+rtf.formatToParts(100, "day");
+// &gt; [{type: "literal", value: "em "},
+// &gt;  { type: "integer", value: "100", unit: "day" },
+// &gt;  {type: "literal", value: " dias"]
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estágio</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td><a href="https://tc39.github.io/proposal-intl-relative-time/#sec-intl-relativetimeformat-constructor">Intl.RelativeTime proposal</a></td>
+   <td>Stage 3</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Browsers">Compatibilidade com Browsers</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Intl.RelativeTimeFormat")}}</p>
+
+<p> </p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="https://developers.google.com/web/updates/2018/10/intl-relativetimeformat">The Intl.RelativeTimeFormat API</a></li>
+</ul>
+
+<p> </p>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/isfinite/index.html b/files/pt-br/web/javascript/reference/global_objects/isfinite/index.html
new file mode 100644
index 0000000000..962bbca928
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/isfinite/index.html
@@ -0,0 +1,128 @@
+---
+title: isFinite()
+slug: Web/JavaScript/Reference/Global_Objects/isFinite
+translation_of: Web/JavaScript/Reference/Global_Objects/isFinite
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p><code><font face="Open Sans, Arial, sans-serif">A função global </font><strong>isFinite()</strong></code> determina se o valor transmitido é um número finito. Se necessário, o parâmetro é primeiro convertido a um número.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">isFinite(<em>testValue</em>)</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>testValue</code></dt>
+ <dd>O valor a ser testado para a finitude</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>isFinite</code> é uma função de nível superior é não é associada com qualquer objeto.</p>
+
+<p>Você pode usar esta função para determinar se um número é um número finito. <code>A função isFinite</code> examina o número em seu argumento. Se o argumento é <code>NaN</code>, positivo infinito, ou negativo infinito, este método retorna <code>false</code>; de outra forma , ele retorna <code>true</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">isFinite(Infinity);  // false
+isFinite(NaN);       // false
+isFinite(-Infinity); // false
+
+isFinite(0);         // true
+isFinite(2e64);      // true
+isFinite(null);      // true
+
+
+isFinite("0");       // true, teria sido false com o
+                     // mais robusto Number.isFinite("0")
+</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('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.2.5', 'isFinite')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-isfinite-number', 'isFinite')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibilidade">Browser compatibilidade</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.isFinite()")}}</li>
+ <li>{{jsxref("Number.NaN()")}}</li>
+ <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
+ <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/isnan/index.html b/files/pt-br/web/javascript/reference/global_objects/isnan/index.html
new file mode 100644
index 0000000000..5e36f9da27
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/isnan/index.html
@@ -0,0 +1,109 @@
+---
+title: isNaN()
+slug: Web/JavaScript/Reference/Global_Objects/isNaN
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/isNaN
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<p>A função <strong><code>isNAN()</code></strong> determina se o valor é {{jsxref("Global_Objects/NaN", "NaN")}} ou não. Tenha cuidado, o <code>cast</code> em <code>isNaN</code> tem regras para serem observadas. Você pode ficar interessado no {{jsxref("Number.isNaN()")}} que foi definido no ECMAScript 6 ou você pode usar <code>typeof</code> para determinar se o valor é Not-A-Number, <code>NaN</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/globalprops-isnan.html")}}</div>
+
+<h2 id="Syntax" name="Syntax">Syntaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>isNaN(<em>value</em>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>O valor a ser testado.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p><strong><code>true</code></strong> se o valor for {{jsxref("NaN")}}; otherwise, <strong><code>false</code></strong>.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<h3 id="The_necessity_of_an_isNaN_function" name="The_necessity_of_an_isNaN_function">A necessidade da função <code>isNaN</code></h3>
+
+<p>Ao contrário de todas as outras possibilidades de valores no JavaScript, não é possivel confiar nos operadores de igualdade <code>(== e ===)</code> para determina se o valor é {{jsxref("Global_Objects/NaN", "NaN")}} ou não, porque ambos, <code>NaN == NaN e NaN === NaN</code>, terá como valor de retorno:<code> false</code>. Daí a necessidade da funçao <code>isNAN</code>.</p>
+
+<h3 id="Origin_of_NaN_values" name="Origin_of_NaN_values">Origem dos valores <code>NaN</code></h3>
+
+<p>Os valores <code>NaN</code> são gerados quando operações aritiméticas tem como valores: <em>undefined</em> ou<em> unrepresentable</em>. Como valores, não fazem necessariamente condições de estouro. <code>NaN</code> também resulta da tentativa de coerção para valores numéricos, de valores não numéricos, para que o valor numérico primitivo seja disponível.</p>
+
+<p>Por exemplo, divida zero por zero e o resultado será <code>NaN</code> , mas se dividir outros números por zero ele não será.</p>
+
+<h3 id="Comportamento_confuso_do_caso_especial">Comportamento confuso do caso especial</h3>
+
+<p><span id="result_box" lang="pt"><span title="Since the very earliest versions of the isNaN function specification, its behavior for non-numeric arguments has been confusing.">Desde as primeiras versões da especificação da função isNaN , o seu comportamento para argumentos não numéricos tem sido confuso. </span><span title="When the argument to the isNaN function is not of type Number, the value is first coerced to a Number.">Quando o argumento para a função <code>isNaN</code> não é do tipo<em> </em></span></span><em><span id="result_box" lang="pt"><span title="When the argument to the isNaN function is not of type Number, the value is first coerced to a Number.">Numbe</span></span></em><span id="result_box" lang="pt"><span title="When the argument to the isNaN function is not of type Number, the value is first coerced to a Number."><em>r</em>, o valor é primeiro convertido para um número. </span><span title='The resulting value is then tested to determine whether it is {{jsxref("Global_Objects/NaN", "NaN")}}.'>O valor resultante é em seguida testado para determinar se se trata de</span></span><span lang="pt"><span title='The resulting value is then tested to determine whether it is {{jsxref("Global_Objects/NaN", "NaN")}}.'> </span></span>{{jsxref("Number.isNaN()")}}. <span lang="pt"><span title='Thus for non-numbers that when coerced to numeric type result in a valid non-NaN numeric value (notably the empty string and boolean primitives, which when coerced give numeric values zero or one), the "false" returned value may be unexpected;'>Assim, para os não-números que quando forçados ao tipo numérico resultado em um valor numérico não-<code>NaN</code> válido (particularmente strings vazias e primitivas booleanas, que quando submetidas ao <code>cast</code> dão valores numéricos zero ou um), o "falso" valor retornado pode ser inesperado; </span><span title='the empty string, for example, is surely "not a number."'>a cadeia vazia , por exemplo, é certamente "not-a-number" </span><span title='The confusion stems from the fact that the term, "not a number", has a specific meaning for numbers represented as IEEE-794 floating-point values.'>A confusão decorre do fato de que o termo, " não é um número " , tem um significado específico para os números representados como valores de ponto flutuante IEEE- 794 . </span><span title="The function should be interpreted as answering the question, &quot;is this value, when coerced to a numeric value, an IEEE-794 'Not A Number' value?&quot;">A função deve ser interpretada como respondendo à pergunta: "este valor, quando convertido para um valor numérico, um valor IEEE -794 ' not-a-number"?</span></span></p>
+
+<p>A ultima versão do ECMAScript (ES6) contém A função {{jsxref("Number.isNaN()")}}. <code>Number.isNaN(x)</code> será a real forma para testar se x é NaN ou não. Mesmo com <code>Number.isNaN</code>, porém, o significado de NaN continua ser a precisão numérica, e não simplesmente, "não é um número = <code>NaN</code>, <em>not a number</em>". Paralelamente , na expressão <code>Number.isNaN</code>, a expressão<code> (x != x)</code> é a forma mais confiável para testar se a variável <code>x </code>é<code> NaN</code> ou não, assim o resultado não é sujeito ao falso positivo que faz <code>isNaN</code> não ser confiável.</p>
+
+<p>A polyfill for <code>isNaN</code> would be (the polyfill leverages the unique never-equal-to-itself characteristic of <code>NaN</code>):</p>
+
+<pre class="brush: js notranslate">var isNaN = function(value) {
+    var n = Number(value);
+    return n !== n;
+};</pre>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<pre class="brush: js notranslate">isNaN(NaN);       // true
+isNaN(undefined); // true
+isNaN({});        // true
+
+isNaN(true);      // false
+isNaN(null);      // false
+isNaN(37);        // false
+
+// strings
+isNaN("37");      // false: "37" is converted to the number 37 which is not NaN
+isNaN("37.37");   // false: "37.37" is converted to the number 37.37 which is not NaN
+isNaN("");        // false: the empty string is converted to 0 which is not NaN
+isNaN(" ");       // false: a string with spaces is converted to 0 which is not NaN
+
+// dates
+isNaN(new Date());                // false
+isNaN(new Date().toString());     // true
+
+// Esse é um falso positivo e é a razão para isNaN não seja totalmente confiável.
+isNaN("blabla")   // true: "blabla" é convertido para número.
+                  // A análise desse número falha e retorna NaN como resultado.
+</pre>
+
+<h3 id="Useful_special-case_behavior">Useful special-case behavior</h3>
+
+<p>There is a more usage oriented way to think of <code>isNaN()</code>: If <code>isNaN(x)</code> returns <code>false</code>, you can use <code>x</code> in an arithmetic expression not making the expression return <code>NaN</code>. If it returns <code>true</code>, <code>x</code> will make every arithmetic expression return <code>NaN</code>. This means that in JavaScript, <code>isNaN(x) == true</code> is equivalent to <code>x - 0</code> returning <code>NaN</code> (though in JavaScript <code>x - 0 == NaN</code> always returns false, so you can't test for it). Actually, <code>isNaN(x)</code>, <code>isNaN(x - 0)</code>, <code>isNaN(Number(x))</code>, <code>Number.isNaN(x - 0)</code>, and <code>Number.isNaN(Number(x))</code> always return the same and in JavaScript <code>isNaN(x)</code> is just the shortest possible form to express each of these terms.</p>
+
+<p>You can use this, for example, to test whether an argument to a function is arithmetically processable (usable "like" a number), or if it's not and you have to provide a default value or something else. This way you can have a function that makes use of the full versatility JavaScript provides by implicitly converting values depending on context.</p>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-isnan-number', 'isNaN')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+
+
+<p>{{Compat("javascript.builtins.isNaN")}}</p>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("NaN")}}</li>
+ <li>{{jsxref("Number.isNaN()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/iterador/index.html b/files/pt-br/web/javascript/reference/global_objects/iterador/index.html
new file mode 100644
index 0000000000..1d00706e61
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/iterador/index.html
@@ -0,0 +1,184 @@
+---
+title: Iterator
+slug: Web/JavaScript/Reference/Global_Objects/Iterador
+translation_of: Archive/Web/Iterator
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<div class="warning"><strong>Non-standard.</strong> The <code><strong>Iterator</strong></code> function is a SpiderMonkey-specific feature, and will be removed at some point. For future-facing usages, consider using <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of" title="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for..of</a> loops and the <a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">iterator protocol</a>.</div>
+
+<p>A função <code><strong>Iterator</strong></code> retorna um objeto que implementa o protocolo legado do iterador e itera sobre propriedades enumeraveis do objeto.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">Iterator(<var>object</var>, [keyOnly])</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>Objeto</code></dt>
+ <dd><span style="background-color: #ffffff; font-size: 1rem; font-style: inherit; font-weight: inherit; letter-spacing: -0.00278rem;">Objeto que itera sobre as propriedades</span></dd>
+ <dd>Se <code>keyOnly</code> for um valor verdadeiro, <code>Iterator.prototype.next</code> retorna somente o <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">nome_da_propriedade</span></font>.</dd>
+</dl>
+
+<h2 id="Description">Description</h2>
+
+<p>Returns <code>Iterator</code> instance that iterates over <code>object</code>. <code>Iterator</code> instance returns <code>[property_name, property_value]</code> array for each iteration if <code>keyOnly</code> is falsy,  otherwise, if <code>keyOnly</code> is truthy, it returns <code>property_name</code> for each iteration.  If <code>object</code> is the <code>Iterator</code> instance or {{jsxref("Generator")}} instance, it returns <code>object</code> itself.</p>
+
+<h2 id="Properties">Properties</h2>
+
+<dl>
+ <dt><code><strong>Iterator.prototype[@@iterator]</strong></code></dt>
+ <dd>Returns a function that returns iterator object, that conforms to {{jsxref("Iteration_protocols", "iterator protocol", "", 1)}}.</dd>
+</dl>
+
+<h2 id="Methods">Methods</h2>
+
+<dl>
+ <dt><code><strong>Iterator.prototype.next</strong></code></dt>
+ <dd>Returns next item in the <code>[property_name, property_value]</code> format or <code>property_name</code> only. It throws <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/StopIteration">StopIteration</a></code> if there are no more items.</dd>
+</dl>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Iterating_over_properties_of_an_object">Iterating over properties of an object</h3>
+
+<pre class="brush: js">var a = {
+  x: 10,
+  y: 20,
+};
+var iter = Iterator(a);
+console.log(iter.next()); // ["x", 10]
+console.log(iter.next()); // ["y", 20]
+console.log(iter.next()); // throws StopIteration
+</pre>
+
+<h3 id="Iterating_over_properties_of_an_object_with_legacy_destructuring_for-in_statement">Iterating over properties of an object with legacy destructuring <code>for-in</code> statement</h3>
+
+<pre class="brush: js">var a = {
+  x: 10,
+  y: 20,
+};
+
+for (var [name, value] in Iterator(a)) {
+  console.log(name, value);   // x 10
+                              // y 20
+}
+</pre>
+
+<h3 id="Iterating_with_for-of">Iterating with <code>for-of</code></h3>
+
+<pre class="brush: js">var a = {
+  x: 10,
+  y: 20,
+};
+
+for (var [name, value] of Iterator(a)) {  // @@iterator is used
+  console.log(name, value);   // x 10
+                              // y 20
+}
+</pre>
+
+<h3 id="Iterates_over_property_name">Iterates over property name</h3>
+
+<pre class="brush: js">var a = {
+  x: 10,
+  y: 20,
+};
+
+for (var name in Iterator(a, true)) {
+  console.log(name);   // x
+                       // y
+}
+</pre>
+
+<h3 id="Passing_Generator_instance">Passing Generator instance</h3>
+
+<pre class="brush: js">function f() {
+  yield "a";
+  yield "b";
+}
+var g = f();
+
+console.log(g == Iterator(g)); // true
+
+for (var v in Iterator(g)) {
+  console.log(v);   // a
+                    // b
+}
+</pre>
+
+<h3 id="Passing_Iterator_instance">Passing Iterator instance</h3>
+
+<pre class="brush: js">var a = {
+  x: 10,
+  y: 20,
+};
+
+var i = Iterator(a);
+
+console.log(i == Iterator(i)); // true
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<p>Non-standard. Not part of any current standards document.</p>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/JavaScript/Guide/Iterators_and_Generators" title="/en-US/docs/JavaScript/Guide/Iterators_and_Generators">Iterators and Generators</a></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/StopIteration">StopIteration</a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/json/index.html b/files/pt-br/web/javascript/reference/global_objects/json/index.html
new file mode 100644
index 0000000000..52b1fa0a7f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/json/index.html
@@ -0,0 +1,241 @@
+---
+title: JSON
+slug: Web/JavaScript/Reference/Global_Objects/JSON
+tags:
+  - JSON
+  - JavaScript
+  - NeedsTranslation
+  - Object
+  - Reference
+  - Référence(2)
+  - TopicStub
+  - polyfill
+translation_of: Web/JavaScript/Reference/Global_Objects/JSON
+---
+<div>{{JSRef("Global_Objects", "JSON")}}</div>
+
+<h2 id="Summary" name="Summary"><span class="short_text" id="result_box" lang="pt"><span class="hps">Resumo</span></span></h2>
+
+<p>O Objeto <strong><code>JSON</code></strong> contém métodos para parsing <a class="external" href="http://json.org/">JavaScript Object Notation</a> ({{glossary("JSON")}}) e conversão de valores para JSON. Ele não pode ser chamado ou construído e, além de suas propriedades de dois métodos, ele não possui uma funcionalidade interessante.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<h3 id="JavaScript_Object_Notation" name="JavaScript_Object_Notation">JavaScript Object Notation</h3>
+
+<p>JSON é uma sintaxe para serialização de objetos, matrizes, números, strings, booleanos, e {{jsxref ("null")}}. Baseia-se em sintaxe Javascript, mas é distinta desta: alguns Javascript não são JSON, e alguns JSON não são Javascript. </p>
+
+<table>
+ <caption>JavaScript e JSON diferenças</caption>
+ <thead>
+  <tr>
+   <th scope="col">JavaScript tipo</th>
+   <th scope="col">JSON diferenças</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>Objetos e Arrays</td>
+   <td>Os nomes das propriedades devem ser strings com aspas duplas; as vírgulas à direita são proibidas.</td>
+  </tr>
+  <tr>
+   <td>Números</td>
+   <td>Zeros à esquerda são proibidos; um ponto decimal deve ser seguido por pelo menos um dígito.</td>
+  </tr>
+  <tr>
+   <td>Strings</td>
+   <td>
+    <p>Apenas um conjunto limitado de caracteres pode ser escapado; certos caracteres de controle são proibidos; o separador de linha Unicode (<a href="http://unicode-table.com/en/2028/">U+2028</a>) e o separador de parágrafo (<a href="http://unicode-table.com/en/2029/">U+2029</a>) caracteres são permitidos; strings devem ter aspas duplas.Veja o exemplo a seguir, onde {{jsxref("JSON.parse()")}} funciona bem e um {{jsxref("SyntaxError")}} é lançado ao avaliar o código como JavaScript: var code = '"\u2028\u2029"'; JSON.parse(code); // works fine eval(code); // fails</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<p>A sintaxe completa do JSON é a seguinte:</p>
+
+<pre><var>JSON</var> = <strong>null</strong>
+    <em>or</em> <strong>true</strong> <em>or</em> <strong>false</strong>
+    <em>or</em> <var>JSONNumber</var>
+    <em>or</em> <var>JSONString</var>
+    <em>or</em> <var>JSONObject</var>
+    <em>or</em> <var>JSONArray</var>
+
+<var>JSONNumber</var> = <strong>-</strong> <var>PositiveNumber</var>
+          <em>or</em> <var>PositiveNumber</var>
+<var>PositiveNumber</var> = DecimalNumber
+              <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var>
+              <em>or</em> <var>DecimalNumber</var> <strong>.</strong> <var>Digits</var> <var>ExponentPart</var>
+              <em>or</em> <var>DecimalNumber</var> <var>ExponentPart</var>
+<var>DecimalNumber</var> = <strong>0</strong>
+             <em>or</em> <var>OneToNine</var> <var>Digits</var>
+<var>ExponentPart</var> = <strong>e</strong> <var>Exponent</var>
+            <em>or</em> <strong>E</strong> <var>Exponent</var>
+<var>Exponent</var> = <var>Digits</var>
+        <em>or</em> <strong>+</strong> <var>Digits</var>
+        <em>or</em> <strong>-</strong> <var>Digits</var>
+<var>Digits</var> = <var>Digit</var>
+      <em>or</em> <var>Digits</var> <var>Digit</var>
+<var>Digit</var> = <strong>0</strong> through <strong>9</strong>
+<var>OneToNine</var> = <strong>1</strong> through <strong>9</strong>
+
+<var>JSONString</var> = <strong>""</strong>
+          <em>or</em> <strong>"</strong> <var>StringCharacters</var> <strong>"</strong>
+<var>StringCharacters</var> = <var>StringCharacter</var>
+                <em>or</em> <var>StringCharacters</var> <var>StringCharacter</var>
+<var>StringCharacter</var> = any character
+                  <em>except</em> <strong>"</strong> <em>or</em> <strong>\</strong> <em>or</em> U+0000 through U+001F
+               <em>or</em> <var>EscapeSequence</var>
+<var>EscapeSequence</var> = <strong>\"</strong> <em>or</em> <strong>\/</strong> <em>or</em> <strong>\\</strong> <em>or</em> <strong>\b</strong> <em>or</em> <strong>\f</strong> <em>or</em> <strong>\n</strong> <em>or</em> <strong>\r</strong> <em>or</em> <strong>\t</strong>
+              <em>or</em> <strong>\u</strong> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var> <var>HexDigit</var>
+<var>HexDigit</var> = <strong>0</strong> through <strong>9</strong>
+        <em>or</em> <strong>A</strong> through <strong>F</strong>
+        <em>or</em> <strong>a</strong> through <strong>f</strong>
+
+<var>JSONObject</var> = <strong>{</strong> <strong>}</strong>
+          <em>or</em> <strong>{</strong> <var>Members</var> <strong>}</strong>
+<var>Members</var> = <var>JSONString</var> <strong>:</strong> <var>JSON</var>
+       <em>or</em> <var>Members</var> <strong>,</strong> <var>JSONString</var> <strong>:</strong> <var>JSON</var>
+
+<var>JSONArray</var> = <strong>[</strong> <strong>]</strong>
+         <em>or</em> <strong>[</strong> <var>ArrayElements</var> <strong>]</strong>
+<var>ArrayElements</var> = <var>JSON</var>
+             <em>or</em> <var>ArrayElements</var> <strong>,</strong> <var>JSON</var>
+</pre>
+
+<p>Espaços em branco podem estar presentes em qualquer lugar, exceto dentro de um JSONNumber (números não devem conter espaço em branco) ou JSONString (onde ele é interpretado como o caractere  correspondente na string, ou causaria um erro). O caractere de tabulação (U+0009), retorno de carro (U+000D), retorno de linha (U+000A), e espaço (U+0020) são os únicos caracteres em branco válidos.</p>
+
+<h2 id="Methods" name="Methods">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("JSON.parse()")}}</dt>
+ <dd><span id="result_box" lang="pt"><span class="hps">Analisar uma seqüência</span> <span class="hps">como</span> <span class="hps">JSON,</span> <span class="hps">opcionalmente</span> <span class="hps">transformar o valor</span> <span class="hps">produzido e</span> <span class="hps">suas propriedades</span><span>,</span> <span class="hps">e retornar o valor</span><span>.</span></span></dd>
+ <dt>{{jsxref("JSON.stringify()")}}</dt>
+ <dd><span id="result_box" lang="pt"><span class="hps">Retorna uma string</span> <span class="hps">JSON</span> <span class="hps">correspondente ao valor</span> <span class="hps">especificado, opcionalmente</span><span>, pode incluir</span> <span class="hps">apenas determinados</span> <span class="hps">propriedades</span> <span class="hps">ou substituir</span> <span class="hps">valores de propriedade</span> <span class="hps">de acordo com a definição feita pelo usuário</span><span class="hps">.</span></span></dd>
+</dl>
+
+<h2 id="Polyfill" name="Polyfill">Polyfill</h2>
+
+<p><span id="result_box" lang="pt"><span class="hps">O objeto</span> <span class="hps">JSON</span> <span class="hps">não é suportado</span> <span class="hps">em navegadores mais antigos</span><span>.</span> <span class="hps">Você pode contornar este problema</span> <span class="hps">inserindo o  seguinte código</span> <span class="hps">no início de</span> <span class="hps">seus scripts,</span> <span class="hps">permitindo o uso de</span> <span class="hps">JSON</span> e navegadores sem suporte<span> (como</span> <span class="hps">Internet</span> <span class="hps">Explorer 6</span><span>)</span><span>.</span></span></p>
+
+<p><span id="result_box" lang="pt"><span class="hps">O algoritmo a seguir</span> <span class="hps">é</span> <span class="hps">uma imitação do</span> <span class="hps">objeto nativo</span> <span class="hps">JSON</span><span>:</span></span></p>
+
+<pre class="brush: js">if (!window.JSON) {
+  window.JSON = {
+    parse: function(sJSON) { return eval('(' + sJSON + ')'); },
+    stringify: (function () {
+      var toString = Object.prototype.toString;
+      var isArray = Array.isArray || function (a) { return toString.call(a) === '[object Array]'; };
+      var escMap = {'"': '\\"', '\\': '\\\\', '\b': '\\b', '\f': '\\f', '\n': '\\n', '\r': '\\r', '\t': '\\t'};
+      var escFunc = function (m) { return escMap[m] || '\\u' + (m.charCodeAt(0) + 0x10000).toString(16).substr(1); };
+      var escRE = /[\\"\u0000-\u001F\u2028\u2029]/g;
+      return function stringify(value) {
+        if (value == null) {
+          return 'null';
+        } else if (typeof value === 'number') {
+          return isFinite(value) ? value.toString() : 'null';
+        } else if (typeof value === 'boolean') {
+          return value.toString();
+        } else if (typeof value === 'object') {
+          if (typeof value.toJSON === 'function') {
+            return stringify(value.toJSON());
+          } else if (isArray(value)) {
+            var res = '[';
+            for (var i = 0; i &lt; value.length; i++)
+              res += (i ? ', ' : '') + stringify(value[i]);
+            return res + ']';
+          } else if (toString.call(value) === '[object Object]') {
+            var tmp = [];
+            for (var k in value) {
+              if (value.hasOwnProperty(k))
+                tmp.push(stringify(k) + ': ' + stringify(value[k]));
+            }
+            return '{' + tmp.join(', ') + '}';
+          }
+        }
+        return '"' + value.toString().replace(escRE, escFunc) + '"';
+      };
+    })()
+  };
+}
+</pre>
+
+<h2 id="Specifications" name="Specifications"><span class="short_text" id="result_box" lang="pt"><span class="hps">Especificações</span></span></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('ES5.1', '#sec-15.12', 'JSON')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-json-object', 'JSON')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Navegador compatível</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("1.9.1")}}</td>
+   <td>{{CompatIE("8.0")}}</td>
+   <td>{{CompatOpera("10.5")}}</td>
+   <td>{{CompatSafari("4.0")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("1.0")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>Baseado em <a class="external" href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.prototype.toJSON()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/json/parse/index.html b/files/pt-br/web/javascript/reference/global_objects/json/parse/index.html
new file mode 100644
index 0000000000..ab6f8a8076
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/json/parse/index.html
@@ -0,0 +1,123 @@
+---
+title: JSON.parse()
+slug: Web/JavaScript/Reference/Global_Objects/JSON/parse
+tags:
+  - JSON
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Global_Objects/JSON/parse
+---
+<div>{{JSRef}}</div>
+
+<p><span class="seoSummary">O método <strong><code>JSON.parse()</code></strong> analisa uma string JSON, construindo o valor ou um objeto JavaScript descrito pela string. Uma função <strong>reviver</strong> opcional pode ser fornecida para executar uma transformação no objeto resultante antes de ser retornada.</span></p>
+
+<div>{{EmbedInteractiveExample("pages/js/json-parse.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">JSON.parse(<var>text</var>[, <var>reviver</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>text</code></dt>
+ <dd>A string para analisar como JSON. Veja o objeto {{jsxref("JSON")}} para uma descrição da sintaxe JSON.</dd>
+ <dt><code>reviver</code> {{optional_inline}}</dt>
+ <dd>Se for uma função, isso prescreve como o valor originalmente produzido pela análise é transformado antes de ser retornado.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O {{jsxref("Object")}} correspondente ao <code>text</code> JSON fornecido.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<p>Lança uma exceção {{jsxref("SyntaxError")}} se a string a ser analisada não for um JSON válido.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_JSON.parse()">Usando <code>JSON.parse()</code></h3>
+
+<pre class="brush: js">JSON.parse('{}');              // {}
+JSON.parse('true');            // true
+JSON.parse('"foo"');           // "foo"
+JSON.parse('[1, 5, "false"]'); // [1, 5, "false"]
+JSON.parse('null');            // null
+</pre>
+
+<h3 id="Usando_o_parâmetro_reviver">Usando o parâmetro <code>reviver</code></h3>
+
+<p>Se um <code>reviver</code> for especificado, o valor calculado pela análise será <em>transformado</em> antes de ser retornado. Especificamente, o valor computado e todas as suas propriedades (começando com as propriedades mais aninhadas e prosseguindo para o próprio valor original) são executadas individualmente através do <code>reviver</code>. Em seguida, ele é chamado, com o objeto contendo a propriedade sendo processada como <code>this</code>, e com o nome da propriedade como uma string, e o valor da propriedade como argumentos. Se a função  <code>reviver</code> retornar {{jsxref("undefined")}} (ou não retornar nenhum valor, por exemplo, se a execução cair no final da função), a propriedade será excluída do objeto. Caso contrário, a propriedade é redefinida para ser o valor de retorno.</p>
+
+<p>Se o <code>reviver</code> apenas transformar alguns valores e não outros, certifique-se de retornar todos os valores não transformados como estão, caso contrário, eles serão excluídos do objeto resultante.</p>
+
+<pre class="brush: js">JSON.parse('{"p": 5}', (key, value) =&gt;
+  typeof value === 'number'
+    ? value * 2 // retorna o valor * 2 para números
+    : value     // retorna tudo sem alteração
+);
+
+// { p: 10 }
+
+JSON.parse('{"1": 1, "2": 2, "3": {"4": 4, "5": {"6": 6}}}', (key, value) =&gt; {
+  console.log(key); // mostra o nome da propriedade atual, o último é "".
+  return value;     // retorna o valor da propriedade inalterada.
+});
+
+// 1
+// 2
+// 4
+// 6
+// 5
+// 3
+// ""
+</pre>
+
+<h3 id="JSON.parse()_não_é_permitido_vírgulas_à_direta"><code>JSON.parse()</code> não é permitido vírgulas à direta</h3>
+
+<pre class="example-bad brush: js example-bad">// ambos retornarão um SyntaxError
+JSON.parse('[1, 2, 3, 4, ]');
+JSON.parse('{"foo" : 1, }');
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.12.2', 'JSON.parse')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.7.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-json.parse', 'JSON.parse')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-json.parse', 'JSON.parse')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.JSON.parse")}}</p>
+</div>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("JSON.stringify()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/json/stringify/index.html b/files/pt-br/web/javascript/reference/global_objects/json/stringify/index.html
new file mode 100644
index 0000000000..ca3138e1bf
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/json/stringify/index.html
@@ -0,0 +1,253 @@
+---
+title: JSON.stringify()
+slug: Web/JavaScript/Reference/Global_Objects/JSON/stringify
+translation_of: Web/JavaScript/Reference/Global_Objects/JSON/stringify
+---
+<div>{{JSRef("Global_Objects", "JSON")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong><code>JSON.stringify()</code></strong> converte valores em javascript para uma String  JSON. Esses valores podem ser substituidos especificando a função <em>replacer</em>, ou incluindo somente as propriedades específicas, quando o array do replacer for especificado.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>JSON.stringify(<var>valor</var>[, <var>replacer</var>[, espaço]])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>valor</code></dt>
+ <dd>O valor a ser convertido para uma string JSON.</dd>
+ <dt><code>replacer</code> {{optional_inline}}</dt>
+ <dd>Uma função que altera o comportamento do processo de transformação em string, ou um array de objetos {{jsxref("String")}} e {{jsxref("Number")}} que servem como uma lista branca para selecionar as propriedades do objeto valor a ser incluído na string JSON. Se este valor for nulo ou não fornecido, todas as propriedades do objeto são incluídas na string JSON resultante.</dd>
+ <dt><code>espaço</code> {{optional_inline}}</dt>
+ <dd>Um objeto {{jsxref("String")}} ou {{jsxref("Number")}} que é usado para inserir espaço em branco na saída da string JSON para propósito de legibilidade. Se isto for um <code>Number</code>, indica o número de caracteres espaço para usar como espaço em branco; este número é limitado em 10 se for maior que isso. Valores menores que 1 indicam que nenhum espaço deve ser usado. Se isto for uma <code>String</code>, a string (ou os primeiros 10 caracteres da string, se for maior que isso) é usado como espaço em branco. Se esse parâmetro não for fornecido (ou for null), nenhum espaço em branco é usado.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><code>JSON.stringify()</code> converte um valor para uma notação JSON que o representa:</p>
+
+<ul>
+ <li>Se o valor tiver um método <code>toJSON()</code>, é responsável por definir quais dados serão serializados.</li>
+ <li>{{jsxref("Boolean")}}, {{jsxref("Number")}}, and {{jsxref("String")}} os objetos são convertidos para os valores primitivos correspondentes durante a stringificação, de acordo com a semântica de conversão.</li>
+ <li>Se {{jsxref("undefined")}}, uma função, ou um symbol é encontrado durante a conversão é omitido (quando é encontrado em um objeto) ou censurado para {{jsxref("null")}} (quando é encontrado em um Array). <code>JSON.stringify</code> pode também somente retornar <code>undefined</code> ao passar valores puros como <code>JSON.stringify(function(){})</code> ou <code>JSON.stringify(undefined)</code>.</li>
+ <li>Todas as propriedades com chave de símbolo serão completamente ignoradas, mesmo quando usar a função  <code>replacer</code>.</li>
+ <li>Propriedades não enumeráveis serão ignoradas.</li>
+</ul>
+
+<pre class="brush: js notranslate">JSON.stringify({});                  // '{}'
+JSON.stringify(true);                // 'true'
+JSON.stringify('foo');               // '"foo"'
+JSON.stringify([1, 'false', false]); // '[1,"false",false]'
+JSON.stringify({ x: 5 });            // '{"x":5}'
+
+JSON.stringify({ x: 5, y: 6 });
+// '{"x":5,"y":6}' or '{"y":6,"x":5}'
+JSON.stringify([new Number(1), new String('false'), new Boolean(false)]);
+// '[1,"false",false]'
+
+// Symbols:
+JSON.stringify({ x: undefined, y: Object, z: Symbol('') });
+// '{}'
+JSON.stringify({ [Symbol('foo')]: 'foo' });
+// '{}'
+JSON.stringify({ [Symbol.for('foo')]: 'foo' }, [Symbol.for('foo')]);
+// '{}'
+JSON.stringify({ [Symbol.for('foo')]: 'foo' }, function(k, v) {
+  if (typeof k === 'symbol') {
+    return 'a symbol';
+  }
+});
+// '{}'
+</pre>
+
+<h3 id="O_parâmetro_replacer_parameter">O parâmetro <code>replacer</code> parameter</h3>
+
+<p dir="ltr" id="tw-target-text">O parâmetro <kbd>replacer</kbd> pode ser uma função ou uma matriz. Como função, são necessários dois parâmetros, a <kbd>chave</kbd> e os valores que estão sendo especificados. O objeto no qual a <kbd>chave</kbd> foi encontrada é fornecido como substituto desse parâmetro. Inicialmente, ele é chamado com uma chave vazia que representa o objeto que está sendo codificado e, em seguida, é chamado para cada propriedade no <kbd>objeto</kbd> ou matriz que está sendo codificada. Ele deve retornar o valor que deve ser adicionado à cadeia JSON, da seguinte maneira:</p>
+
+<ul>
+ <li>Se você retornar um {{jsxref("Number")}}, a string correspondente a esse número é usada como o valor da propriedade quando adicionada à sequência JSON.</li>
+ <li>If you return a {{jsxref("String")}}, that string is used as the property's value when adding it to the JSON string.</li>
+ <li>If you return a {{jsxref("Boolean")}}, "true" or "false" is used as the property's value, as appropriate, when adding it to the JSON string.</li>
+ <li>If you return any other object, the object is recursively stringified into the JSON string, calling the <code>replacer</code> function on each property, unless the object is a function, in which case nothing is added to the JSON string.</li>
+ <li>If you return <code>undefined</code>, the property is not included in the output JSON string. </li>
+</ul>
+
+<div class="blockIndicator note">
+<p><strong>Nota: </strong>Você não pode usar a função <code>replacer</code> para remover valoeres em uma <code>array</code>. Se você retornar <code>undefined</code>, <code>null</code> será usado no lugar.</p>
+</div>
+
+<h4 id="Exemplo_de_uma_função">Exemplo de uma função</h4>
+
+<pre class="brush: js notranslate">function <span style="font-size: 1rem;">replacer</span><span style="font-size: 1rem;">(key, value) {</span>
+  if (typeof value === "string") {
+    return undefined;
+  }
+  return value;
+}
+
+var foo = {fundação: "Mozilla", modelo: "caixa", semana: 45, transporte: "carro", mês: 7};
+var jsonString = JSON.stringify(foo, replacer);
+</pre>
+
+<p>O resultado do JSON é:  <code>{"semana":45,"mês":7}</code>.</p>
+
+<h4 id="Example_of_using_replacer_parameter" name="Example_of_using_replacer_parameter">Exemplo em uma array</h4>
+
+<p>Se <code>replacer</code> é usado em uma array, os valores da array indicam os nomes das propriedades no objeto, que devem ser incluídas na sequência JSON resultante.</p>
+
+<pre class="brush: js notranslate">JSON.stringify(foo, ['week', 'month']);
+// '{"week":45,"month":7}', only keep "week" and "month" properties
+</pre>
+
+<h3 id="space_argument" name="space_argument">O argumento <code>space</code> </h3>
+
+<p>O argumento <code>space</code> O argumento pode ser usado para controlar o espaçamento na sequência final. Se for um número, os níveis sucessivos na stringficação serão recuados por esse número de caracteres de espaço (até 10). Se for uma sequência, os níveis sucessivos serão recuados por essa sequência (ou pelos dez primeiros caracteres).</p>
+
+<pre class="brush: js notranslate">JSON.stringify({ a: 2 }, null, ' ');
+// '{
+//  "a": 2
+// }'
+</pre>
+
+<p>O uso de um caractere de tabulação imita a aparência padrão de impressão pretty-print.</p>
+
+<pre class="brush: js notranslate">JSON.stringify({ uno: 1, dos: 2 }, null, '\t');
+// r:
+// '{
+//     "uno": 1,
+//     "dos": 2
+// }'
+</pre>
+
+<h3 id="toJSON_behavior" name="toJSON_behavior">Comportamento de <code>toJSON()</code></h3>
+
+<p>Se um objeto sendo stringificado tiver uma propriedade denominada <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">toJSON()</span></font> cujo valor é uma função, o método <code>toJSON()</code> personaliza o comportamento da stringificação JSON, em vez de o objeto ser serializado, o valor retornado pelo método <code>toJSON()</code> quando chamado será serializado. Por exemplo:</p>
+
+<pre class="brush: js notranslate">var obj = {
+  foo: 'foo',
+  toJSON: function() {
+    return 'bar';
+  }
+};
+JSON.stringify(obj);        // '"bar"'
+JSON.stringify({ x: obj }); // '{"x":"bar"}'
+</pre>
+
+<h3 id="Example_of_using_JSON.stringify_with_localStorage" name="Example_of_using_JSON.stringify_with_localStorage">Examplo de uso de <code>JSON.stringify()</code> com <code>localStorage</code></h3>
+
+<p>No caso em que você deseja armazenar um objeto criado por seu usuário e permitir que ele seja restaurado mesmo após o fechamento do navegador, o exemplo a seguir é um modelo para a aplicabilidade de <code>JSON.stringify()</code>:</p>
+
+<div class="warning">
+<p>As funções não são um tipo de dados JSON válido, portanto, elas não funcionarão. Também alguns objetos como {{jsxref("Date")}} será uma string depois {{jsxref("JSON.parse()")}}.</p>
+</div>
+
+<pre class="brush: js notranslate">// Criando um exemplo em JSON
+var seção = {
+  'telas': [],
+  'estado': true
+};
+session.screens.push({ 'nome': 'telaA', 'largura': 450, 'altura': 250 });
+session.screens.push({ 'nome': 'telaB', 'largura': 650, 'altura': 350 });
+session.screens.push({ 'nome': 'telaC', 'largura': 750, 'altura': 120 });
+session.screens.push({ 'nome': 'telaD', 'largura': 250, 'altura': 60 });
+session.screens.push({ 'nome': 'telaE', 'largura': 390, 'altura': 120 });
+session.screens.push({ 'nome': 'telaF', 'largura': 1240, 'altura': 650 });
+
+// Convertendo a string JSON em JSON.stringify()
+// Salvando com localStorage no nome da sessão
+localStorage.setItem('seção', JSON.stringify(seção));
+
+// Exemplo de como transformar a String gerada por meio de:
+// JSON.stringify() e salva em localStorage no objeto JSON novamente
+var seçãoRestaurada = JSON.parse(localStorage.getItem('seção'));
+
+// Agora, a variável seçãoRestaurada contém o objeto que foi salvo
+// no localStorage
+console.log(seçãoRestaurada);
+</pre>
+
+<h2 id="Specifications" name="Specifications">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('ES5.1', '#sec-15.12.3', 'JSON.stringify')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>
+    <p dir="ltr" id="tw-target-text">Definição inicial. Implementado em JavaScript 1.7.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-json.stringify', 'JSON.stringify')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade em navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Navegador</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("1.9.1")}}</td>
+   <td>{{CompatIE("8.0")}}</td>
+   <td>{{CompatOpera("10.5")}}</td>
+   <td>{{CompatSafari("4.0")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("1.0")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>Baseado na <a class="external" href="http://kangax.github.com/es5-compat-table/">Kangax's compat table</a>.</p>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("JSON.parse()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/clear/index.html b/files/pt-br/web/javascript/reference/global_objects/map/clear/index.html
new file mode 100644
index 0000000000..19482e19c8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/clear/index.html
@@ -0,0 +1,119 @@
+---
+title: Map.prototype.clear()
+slug: Web/JavaScript/Reference/Global_Objects/Map/clear
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Mapa
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/clear
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>clear()</strong></code> remove todos os elementos de um objeto <code>Map</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>meuMapa</em>.clear();</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>{{jsxref("undefined")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_clear">Usando o método <code>clear</code></h3>
+
+<pre class="brush: js">var meuMapa = new Map();
+meuMapa.set('bar', 'baz');
+meuMapa.set(1, 'foo');
+
+meuMapa.size;       // 2
+meuMapa.has('bar'); // true
+
+meuMapa.clear();
+
+meuMapa.size;       // 0
+meuMapa.has('bar')  // false
+</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('ES2015', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.clear', 'Map.prototype.clear')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{CompatGeckoDesktop("19.0")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatGeckoMobile("19.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/delete/index.html b/files/pt-br/web/javascript/reference/global_objects/map/delete/index.html
new file mode 100644
index 0000000000..f4b0ae0786
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/delete/index.html
@@ -0,0 +1,120 @@
+---
+title: Map.prototype.delete()
+slug: Web/JavaScript/Reference/Global_Objects/Map/delete
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Mapa
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/delete
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>delete()</strong></code> remove o elemento especificado de um objeto <code>Map</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush: js">meuMapa.delete(chave);</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>key</dt>
+ <dd>Obrigatório. A chave do elemento a ser removido do objeto <code>Map</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Retorna <code>true</code> se um elemento existia no objeto <code>Map</code> e foi removido, ou <code>false</code> se o elemento não existia.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_delete">Usando o método <code>delete</code></h3>
+
+<pre class="brush: js">var meuMapa = new Map();
+meuMapa.set('bar', 'foo');
+
+meuMapa.delete('bar'); // Retorna true. Removido com sucesso.
+meuMapa.has('bar');    // Retorna false. O elemento com valor "bar" já não existe mais no mapa.
+</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('ES2015', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.delete', 'Map.prototype.delete')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{CompatGeckoDesktop("13.0")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatGeckoMobile("13.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/entries/index.html b/files/pt-br/web/javascript/reference/global_objects/map/entries/index.html
new file mode 100644
index 0000000000..cdea688bf2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/entries/index.html
@@ -0,0 +1,120 @@
+---
+title: Map.prototype.entries()
+slug: Web/JavaScript/Reference/Global_Objects/Map/entries
+tags:
+  - ECMAScript 2015
+  - Iterador
+  - JavaScript
+  - Mapa
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/entries
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>entries()</strong></code> retorna um novo objeto <strong><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterador</a></strong> que contém os pares <code>[chave, valor]</code> para cada elemento no objeto <code>Map</code> pela ordem de inserção.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>meuMapa</em>.entries()</code></pre>
+
+<h3 id="Retorna_o_valor">Retorna o valor</h3>
+
+<p>Um novo objeto iterador de {{jsxref("Map")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_entries()">Usando <code>entries()</code></h3>
+
+<pre class="brush:js">var meuMap = new Map();
+meuMap.set('0', 'foo');
+meuMap.set(1, 'bar');
+meuMap.set({}, 'baz');
+
+var mapIter = myMap.entries();
+
+console.log(mapIter.next().value); // ["0", "foo"]
+console.log(mapIter.next().value); // [1, "bar"]
+console.log(mapIter.next().value); // [Object, "baz"]
+</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('ES2015', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.entries', 'Map.prototype.entries')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{ CompatGeckoDesktop("20") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatGeckoMobile("20")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype.keys()")}}</li>
+ <li>{{jsxref("Map.prototype.values()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/foreach/index.html b/files/pt-br/web/javascript/reference/global_objects/map/foreach/index.html
new file mode 100644
index 0000000000..1aed37b31c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/foreach/index.html
@@ -0,0 +1,146 @@
+---
+title: Map.prototype.forEach()
+slug: Web/JavaScript/Reference/Global_Objects/Map/forEach
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Mapa
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/forEach
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>forEach()</strong></code> executa uma função fornecida uma vez para cada par de chave/valor no objeto <code>Map</code>, pela ordem de inserção.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>meuMapa</em>.forEach(<em>callback</em>[, <em>thisArg</em>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callback</code></dt>
+ <dd>Função a ser executada para cada elemento.</dd>
+ <dt><code>thisArg</code></dt>
+ <dd>Valor a utilizar como o <code>this</code> quando estiver executando o <code>callback</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>{{jsxref("undefined")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>forEach</code> executa o <code>callback</code> fornecido uma vez para cada chave existente no mapa. Ele não é invocado para as chaves que foram removidas. No entanto, ele é executado para ítens que estão presentes mesmo com o valor <code>undefined</code>.</p>
+
+<p><code>callback</code> é invocado com <strong>três argumentos</strong>:</p>
+
+<ul>
+ <li>o <strong>valor do elemento</strong></li>
+ <li>a <strong>chave do elemento</strong></li>
+ <li>o <strong><code>Objeto Map</code> que está sendo atravessado</strong></li>
+</ul>
+
+<p>Se um parâmetro <code>thisArg</code> for fornecido ao <code>forEach</code>, ele será passado ao <code>callback</code> quando invocado, e será utilizado como o valor de seu <code>this</code>.  De outra forma, o valor <code>undefined</code> será passado como o valor de seu <code>this</code>.  O valor <code>this</code> observável em última instância por callback é determinado de acordo com <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">as regras comuns para determinar o <code>this</code> sendo visto por uma função</a>.</p>
+
+<p>Cada valor é visitado uma vez, exceto para o caso em que ele foi removido e re-adicionado antes do <code>forEach</code> ter acabado de ser executado. o <code>callback</code> não é invocado para valores removidos antes de serem visitados. Novos valores adicionados antes do <code>forEach</code> ter acabado serão visitados.</p>
+
+<p><code>forEach</code> executa a função de <code>callback</code> uma vez para cada elemento no objeto <code>Map</code>; ele não retorna um valor.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Imprimindo_o_conteúdo_de_um_objeto_Map">Imprimindo o conteúdo de um objeto <code>Map</code></h3>
+
+<p>O código a seguir registra uma linha de log para cada elemento no objeto <code>Map</code>:</p>
+
+<pre class="brush:js">function registrarElementosDoMapa(valor, chave, mapa) {
+    console.log(`m[${chave}] = ${valor}`);
+}
+new Map([['foo', 3], ['bar', {}], ['baz', undefined]]).forEach(registrarElementosDoMapa);
+// logs:
+// "m[foo] = 3"
+// "m[bar] = [object Object]"
+// "m[baz] = undefined"
+</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('ES2015', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.foreach', 'Map.prototype.forEach')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{CompatGeckoDesktop("25.0")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatGeckoMobile("25.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+ <li>{{jsxref("Set.prototype.forEach()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/get/index.html b/files/pt-br/web/javascript/reference/global_objects/map/get/index.html
new file mode 100644
index 0000000000..9a4fde282c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/get/index.html
@@ -0,0 +1,76 @@
+---
+title: Map.prototype.get()
+slug: Web/JavaScript/Reference/Global_Objects/Map/get
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Map
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/get
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>get()</strong></code> retorna um elemento específico de um objeto de <code>Map</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.get(chave);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>chave</dt>
+ <dd>Obrigatório. A chave do elemento para retornar do objeto de <code>Map</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Retorna o elemento associado com a chave específica ou <code>undefined</code> se a chave não puder ser encontrada no objeto de <code>Map</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_métodoget">Usando o método<code>get</code></h3>
+
+<pre class="brush: js">var myMap = new Map();
+myMap.set('bar', 'foo');
+
+myMap.get('bar');  // Retorna "foo".
+myMap.get('baz');  // Retorna undefined.
+</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('ES2015', '#sec-map.prototype.get', 'Map.prototype.get')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.get', 'Map.prototype.get')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div class="hidden">A tabela de compatibilidade desta página é gerada a partir de dados estruturados. Se você gostaria de contribuir, por favor, dê uma olhada em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</div>
+
+<p>{{Compat("javascript.builtins.Map.get")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("Map.prototype.set()")}}</li>
+ <li>{{jsxref("Map.prototype.has()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/has/index.html b/files/pt-br/web/javascript/reference/global_objects/map/has/index.html
new file mode 100644
index 0000000000..88a5c18aff
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/has/index.html
@@ -0,0 +1,78 @@
+---
+title: Map.prototype.has()
+slug: Web/JavaScript/Reference/Global_Objects/Map/has
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/has
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>has()</code></strong> retorna um valor booleano indicando quando um elemento com a chave especificada existe ou não</p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-has.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.has(key);</code></pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt>key</dt>
+ <dd>Necessário. A chave para verificar a presença do elemento no objeto <code>Map</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<dl>
+ <dt>Booleano</dt>
+ <dd>Retorna <code>true</code> se um elemento com a chave especificada existe no objeto <code>Map</code>; caso contrário: <code>false</code>.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_has">Usando o método <code>has</code></h3>
+
+<pre class="brush: js">var myMap = new Map();
+myMap.set('bar', "foo");
+
+myMap.has('bar');  // retorna true
+myMap.has('foo'); // retorna false
+myMap.has('barz');  // retorna false
+</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('ES2015', '#sec-map.prototype.has', 'Map.prototype.has')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.has', 'Map.prototype.has')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.has")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("Map.prototype.set()")}}</li>
+ <li>{{jsxref("Map.prototype.get()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/index.html b/files/pt-br/web/javascript/reference/global_objects/map/index.html
new file mode 100644
index 0000000000..80ec04af62
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/index.html
@@ -0,0 +1,225 @@
+---
+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>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/keys/index.html b/files/pt-br/web/javascript/reference/global_objects/map/keys/index.html
new file mode 100644
index 0000000000..40637e641d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/keys/index.html
@@ -0,0 +1,115 @@
+---
+title: Map.prototype.keys()
+slug: Web/JavaScript/Reference/Global_Objects/Map/keys
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/keys
+---
+<div>{{JSRef}}</div>
+
+<div>O método <code><strong>keys()</strong></code> retorna um novo objeto do tipo <code><strong>Iterator</strong></code> que contem uma chave para cada elemento dentro do objeto <code>Map </code>na ordem que foram inseridos.</div>
+
+<p> </p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.keys()</code></pre>
+
+<h3 id="Tipo_de_Retorno">Tipo de Retorno</h3>
+
+<p>Um novo objeto {{jsxref("Map")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_keys()">Usando <code>keys()</code></h3>
+
+<pre class="brush:js">var myMap = new Map();
+myMap.set("0", "foo");
+myMap.set(1, "bar");
+myMap.set({}, "baz");
+
+var mapIter = myMap.keys();
+
+console.log(mapIter.next().value); // "0"
+console.log(mapIter.next().value); // 1
+console.log(mapIter.next().value); // Object
+</pre>
+
+<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>{{SpecName('ES6', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.keys', 'Map.prototype.keys')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{CompatGeckoDesktop("20")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatGeckoMobile("20") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype.entries()")}}</li>
+ <li>{{jsxref("Map.prototype.values()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/map/prototype/index.html
new file mode 100644
index 0000000000..7ff81b758a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/prototype/index.html
@@ -0,0 +1,135 @@
+---
+title: Map.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Map/prototype
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Mapa
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Map
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code><strong>Map</strong></code><strong><code>.prototype</code></strong> representa o protótipo para o construtor {{jsxref("Map")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Instâncias de {{jsxref("Map")}} herdam de {{jsxref("Map.prototype")}}. Você pode utilizar o objeto protótipo do  construtor para adicionar propriedades ou métodos para todas as instâncias de <code>Map</code>.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>Map.prototype.constructor</code></dt>
+ <dd>Retorna a função que criou um protótipo da instância. Isso é a funçao de {{jsxref("Map")}} por padrão.</dd>
+ <dt>{{jsxref("Map.prototype.size")}}</dt>
+ <dd>Retorna o número de pares chave/valor no objeto <code>Map</code>.</dd>
+</dl>
+
+<h2 id="Metódos">Metódos</h2>
+
+<dl>
+ <dt>{{jsxref("Map.prototype.clear()")}}</dt>
+ <dd>Remove todas os pares chave/valor do objeto <code>Map</code>.</dd>
+ <dt>{{jsxref("Map.delete", "Map.prototype.delete(chave)")}}</dt>
+ <dd>Remove qualquer valor associado à chave passada e retorna o valor que <code>Map.prototype.has(chave)</code> deveria retornar anteriormente. <code>Map.prototype.has(chave)</code> irá retornar <code>false</code> após tal remoção ser feita.</dd>
+ <dt>{{jsxref("Map.prototype.entries()")}}</dt>
+ <dd>Retorna um novo objeto <code>Iterador</code> que contem<strong> um array de <code>[chave, valor]</code></strong> para cada elemento no objeto <code>Map</code> pela ordem de inserção.</dd>
+ <dt>{{jsxref("Map.forEach", "Map.prototype.forEach(callbackFn[, thisArg])")}}</dt>
+ <dd>Chama callbackFn uma vez para cada par chave/valor presente no objeto <code>Map</code>, pela ordem de inserção. Se um parâmetro thisArg for fornecido para o forEach, ele será utilizado como o valor this para cada callback.</dd>
+ <dt>{{jsxref("Map.get", "Map.prototype.get(chave)")}}</dt>
+ <dd>Retorna o valor associado para a <code>chave</code>, ou <code>undefined</code> se esta não existir no objeto <code>Map</code>.</dd>
+ <dt>{{jsxref("Map.has", "Map.prototype.has(key)")}}</dt>
+ <dd>Retorna um valor booleano caso um valor tenha sido associado à <code>chave</code> no objeto <code>Map</code> ou não.</dd>
+ <dt>{{jsxref("Map.prototype.keys()")}}</dt>
+ <dd>Retorna um novo objeto <code>Iterador</code> que contem as <strong>chaves</strong> para cada elemento no objeto <code>Map</code> object pela ordem de inserção.</dd>
+ <dt>{{jsxref("Map.set", "Map.prototype.set(key, value)")}}</dt>
+ <dd>Configura o valor par a <code>chave</code> no objeto <code>Map</code>. Retorna o objeto <code>Map</code>.</dd>
+ <dt>{{jsxref("Map.prototype.values()")}}</dt>
+ <dd>Retorna um novo objeto <code>Iterador</code> que contém os <strong>valores</strong> para cada elemento no objeto <code>Map</code> pela ordem de inserção.</dd>
+ <dt>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</dt>
+ <dd>Retorna um novo objeto <code>Iterator</code> que contém<strong> um array de <code>[chave, valor]</code></strong> para cada elemento no objeto <code>Map</code> pela ordem de inserção.</dd>
+</dl>
+
+<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>{{SpecName('ES2015', '#sec-map.prototype', 'Map.prototype')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype', 'Map.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{ CompatGeckoDesktop("13") }}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatGeckoMobile("13")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>
+    <p>8</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Set.prototype")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/set/index.html b/files/pt-br/web/javascript/reference/global_objects/map/set/index.html
new file mode 100644
index 0000000000..e161bb2926
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/set/index.html
@@ -0,0 +1,137 @@
+---
+title: Map.prototype.set()
+slug: Web/JavaScript/Reference/Global_Objects/Map/set
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Map
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/set
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>set()</strong></code> adiciona ou atualiza um elemento com uma <code>chave</code> e <code>valor</code> específicos a um objeto de <code>Map.</code></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>myMap</em>.set(chave, valor);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>chave</dt>
+ <dd>Obrigatório. A chave do elemento para adicionar ao objeto de <code>Map</code>.</dd>
+ <dt>valor</dt>
+ <dd>Obrigatório. O valor do elemento para adicionar ao objeto de <code>Map</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto de <code>Map</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_set">Usando o método <code>set</code> </h3>
+
+<pre class="brush: js">var myMap = new Map();
+
+// adiciona novos elementos ao map
+myMap.set('bar', 'foo');
+myMap.set(1, 'foobar');
+
+// Atualiza um elemento no map
+myMap.set('bar', 'baz');
+</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('ES2015', '#sec-map.prototype.set', 'Map.prototype.set')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td><span style="display: none;"> </span>Definição    inicial.</td>
+  </tr>
+  <tr>
+   <td><span style="display: none;"> </span>{{SpecName('ESDraft', '#sec-map.prototype.set', 'Map.prototype.set')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("13.0")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("13.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_sobre_compatibilidade">Notas sobre compatibilidade</h2>
+
+<ul>
+ <li>Antes do Firefox 33 {{geckoRelease("33")}}, <code>Map.prototype.set</code> retornava <code>undefined</code> e não era encadeável. Isso foi corrigido ({{bug(1031632)}}). O comportamento também pode ser encontrado no Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">issue</a>) e IE11.</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("Map.prototype.get()")}}</li>
+ <li>{{jsxref("Map.prototype.has()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/size/index.html b/files/pt-br/web/javascript/reference/global_objects/map/size/index.html
new file mode 100644
index 0000000000..6ce3b4ff7a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/size/index.html
@@ -0,0 +1,110 @@
+---
+title: Map.prototype.size
+slug: Web/JavaScript/Reference/Global_Objects/Map/size
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/size
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade de acesso <code><strong>size</strong></code> retorna o número de elementos em um objeto {{jsxref("Map")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O valor de <code>size</code> é um integer representando quantas entradas o objeto <code>Map</code> tem. Uma function set de acesso ao size é <code>undefined</code>; você não pode trocar esta propriedade.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_size">Usando <code>size</code></h3>
+
+<pre class="brush:js">var myMap = new Map();
+myMap.set("a", "alpha");
+myMap.set("b", "beta");
+myMap.set("g", "gamma");
+
+myMap.size // 3
+</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-get-map.prototype.size', 'Map.prototype.size')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição Inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-get-map.prototype.size', 'Map.prototype.size')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{ CompatGeckoDesktop("19") }}</td>
+   <td>{{ CompatIE("11") }}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatGeckoMobile("19")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Gecko_-_Notas_específicas">Gecko - Notas específicas</h2>
+
+<ul>
+ <li>Do Gecko 13 {{geckoRelease("13")}} ao Gecko 18 {{geckoRelease("18")}} a propriedade size foi implementada como um metodo <strong><code>Map.prototype.size()</code></strong>, isto foi trocado para uma propriedade em versões posteriores conforme a especificação ECMAScript 6 ({{bug("807001")}}).</li>
+</ul>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/map/values/index.html b/files/pt-br/web/javascript/reference/global_objects/map/values/index.html
new file mode 100644
index 0000000000..8bb1e96bca
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/map/values/index.html
@@ -0,0 +1,74 @@
+---
+title: Map.prototype.values()
+slug: Web/JavaScript/Reference/Global_Objects/Map/values
+tags:
+  - Iterador
+  - Mapa
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Map/values
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>values()</strong></code> retorna um novo objeto <strong><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Iterator</a></strong> que contém os valores de cada elemento do objeto <code>Map</code> em ordem de inserção.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/map-prototype-values.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>meuMap</em>.values()</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um novo objeto iterador do {{jsxref("Map")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_values()">Usando o <code>values()</code></h3>
+
+<pre class="brush:js">var meuMap = new Map();
+meuMap.set('0', 'foo');
+meuMap.set(1, 'bar');
+meuMap.set({}, 'baz');
+
+var mapIter = myMap.values();
+
+console.log(mapIter.next().value); // "foo"
+console.log(mapIter.next().value); // "bar"
+console.log(mapIter.next().value); // "baz"</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('ES2015', '#sec-map.prototype.values', 'Map.prototype.values')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-map.prototype.values', 'Map.prototype.values')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Map.values")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype.entries()")}}</li>
+ <li>{{jsxref("Map.prototype.keys()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/abs/index.html b/files/pt-br/web/javascript/reference/global_objects/math/abs/index.html
new file mode 100644
index 0000000000..1a3658a719
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/abs/index.html
@@ -0,0 +1,142 @@
+---
+title: Math.abs()
+slug: Web/JavaScript/Reference/Global_Objects/Math/abs
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/abs
+---
+<div>{{JSRef("Global_Objects", "Math")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A função <code><strong>Math.abs(x)</strong></code> retorna o valor absoluto de um número "x", tal qual:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.abs</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><mo>=</mo><mrow><mo>{</mo><mtable columnalign="left left"><mtr><mtd><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>&gt;</mo><mn>0</mn></mtd></mtr><mtr><mtd><mi>0</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>=</mo><mn>0</mn></mtd></mtr><mtr><mtd><mo>-</mo><mi>x</mi></mtd><mtd><mtext>if</mtext><mspace width="1em"></mspace><mi>x</mi><mo>&lt;</mo><mn>0</mn></mtd></mtr></mtable></mrow></mrow><annotation encoding="TeX">{\mathtt{\operatorname{Math.abs}(x)}} = {|x|} = \begin{cases} x &amp; \text{if} \quad x \geq 0 \\ -x &amp; \text{if} \quad x &lt; 0 \end{cases} </annotation></semantics></math></p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox">var abs = Math.abs(<em>x</em>);</pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>O valor absoluto do número passado</p>
+
+<h2 id="Description" name="Description">Descrição.</h2>
+
+<p>Por <code>abs</code> ser um método estático de <code>Math</code>, você sempre o usará como <code>Math.abs() </code>ao ínves de usar como método de um objeto <code>Math</code> criado por você. (<code>Math</code> não é um construtor);</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Math.abs_behavior" name="Example:_Math.abs_behavior">Comportamento de <code>Math.abs()</code></h3>
+
+<p>Passando um string não-numérica ou variável indefinida/vazia retorna <code>NaN</code>. Passando null retorna 0.</p>
+
+<pre class="brush: js">Math.abs('-1');     // 1
+Math.abs(-2);       // 2
+Math.abs(null);     // 0
+Math.abs('');       // 0
+Math.abs([]);       // 0
+Math.abs([2]);      // 2
+Math.abs([1,2]);    // NaN
+Math.abs({});       // NaN
+Math.abs('string'); // NaN
+Math.abs();         // NaN</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.1', 'Math.abs')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.abs', 'Math.abs')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.abs', 'Math.abs')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Math.ceil()")}}</li>
+ <li>{{jsxref("Math.floor()")}}</li>
+ <li>{{jsxref("Math.round()")}}</li>
+ <li>{{jsxref("Math.sign()")}}</li>
+ <li>{{jsxref("Math.trunc()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/acos/index.html b/files/pt-br/web/javascript/reference/global_objects/math/acos/index.html
new file mode 100644
index 0000000000..beea711e08
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/acos/index.html
@@ -0,0 +1,139 @@
+---
+title: Math.acos()
+slug: Web/JavaScript/Reference/Global_Objects/Math/acos
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/acos
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.acos()</code></strong> retorna o arco cosseno (em radianos de um numero, sendo esse</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arccos</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mo stretchy="false">[</mo><mn>0</mn><mo>;</mo><mi>π</mi><mo stretchy="false">]</mo><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cos</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.acos}(x)} = \arccos(x) = \text{ O unico } \; y \in [0; \pi] \, \text{such that} \; \cos(y) = x</annotation></semantics></math></p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><code>Math.acos(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros"><strong>Parâmetros</strong> </h3>
+
+<dl>
+ <dd>Um numero.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>O arco cosseno(em radianos) se o valor passado como parâmetro for entre -1 e 1; caso contrario retornará {{jsxref("NaN")}}.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>O <code>Math.acos()</code> metodo retorna um numero entre 0 e π radians para valores passado como parâmetros entre -1 e 1. Se o valor estiver fora dessa variação será returnado {{jsxref("NaN")}}.</p>
+
+<p>Porque <code>acos() é um metodo estático</code>, você sempre usará <code>Math.acos() ao invés de criar um Objecto Math(Math não é um construtor).</code></p>
+
+<h2 id="Examplos">Examplos</h2>
+
+<h3 id="Usando_Math.acos()">Usando <code>Math.acos()</code></h3>
+
+<pre class="brush: js">Math.acos(-2);  // NaN
+Math.acos(-1);  // 3.141592653589793
+Math.acos(0);   // 1.5707963267948966
+Math.acos(0.5); // 1.0471975511965979
+Math.acos(1);   // 0
+Math.acos(2);   // NaN
+</pre>
+
+<p>Para valores menores que -1 ou maiores que than 1, <code>Math.acos()</code> o método retornrá {{jsxref("NaN")}}.</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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.2', 'Math.acos')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.acos', 'Math.acos')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.acos', 'Math.acos')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/acosh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/acosh/index.html
new file mode 100644
index 0000000000..d80acedc5d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/acosh/index.html
@@ -0,0 +1,100 @@
+---
+title: Math.acosh()
+slug: Web/JavaScript/Reference/Global_Objects/Math/acosh
+tags:
+  - JavaScript
+  - Math
+  - Method
+  - Reference
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/acosh
+---
+<div>{{JSRef}}</div>
+
+<p>A função Math.acosh() retorna o arco cosseno hiperbólico de um número, onde</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>≥</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.acosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>≥</mo><mn>0</mn><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">cosh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \geq 1, \mathtt{\operatorname{Math.acosh}(x)} = \operatorname{arcosh}(x) = \text{ the unique } \; y \geq 0 \; \text{such that} \; \cosh(y) = x</annotation></semantics></math></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.acosh(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>The hyperbolic arc-cosine of the given number. If the number is less than <strong>1</strong>, {{jsxref("NaN")}}.</p>
+
+<p>O arco cosseno hiperbólico do número recebido. Se o número for menor que 1, {{jsxref("NaN")}} é retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por <code>acosh()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.acosh()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.acosh()">Usando <code>Math.acosh()</code></h3>
+
+<pre class="brush: js">Math.acosh(-1);  // NaN
+Math.acosh(0);   // NaN
+Math.acosh(0.5); // NaN
+Math.acosh(1);   // 0
+Math.acosh(2);   // 1.3169578969248166
+</pre>
+
+<p>For values less than 1 <code>Math.acosh()</code> returns {{jsxref("NaN")}}.</p>
+
+<p>Para valores menores que 1, <code>Math.acosh()</code> retornará {{jsxref("NaN")}}.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Para todo <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>1</mn></mrow><annotation encoding="TeX">x \geq 1</annotation></semantics></math>, temos <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">arcosh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mrow><mi>x</mi><mo>+</mo><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>-</mo><mn>1</mn></mrow></msqrt></mrow><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {arcosh} (x) = \ln \left(x + \sqrt{x^{2} - 1} \right)</annotation></semantics></math>. Dessa maneira, este comportamento pode ser emulado da seguinte maneira:</p>
+
+<pre class="brush: js">Math.acosh = Math.acosh || function(x) {
+  return Math.log(x + Math.sqrt(x * x - 1));
+};
+</pre>
+
+<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>{{SpecName('ES6', '#sec-math.acosh', 'Math.acosh')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.acosh', 'Math.acosh')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.acosh")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Math.asinh()")}}</li>
+ <li>{{jsxref("Math.atanh()")}}</li>
+ <li>{{jsxref("Math.cosh()")}}</li>
+ <li>{{jsxref("Math.sinh()")}}</li>
+ <li>{{jsxref("Math.tanh()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/asin/index.html b/files/pt-br/web/javascript/reference/global_objects/math/asin/index.html
new file mode 100644
index 0000000000..7738c1e819
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/asin/index.html
@@ -0,0 +1,103 @@
+---
+title: Math.asin()
+slug: Web/JavaScript/Reference/Global_Objects/Math/asin
+tags:
+  - JavaScript
+  - Math
+  - Method
+  - Método(2)
+  - Reference
+  - Referência(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/asin
+---
+<div>{{JSRef}}</div>
+
+<p> </p>
+
+<p>A função Math.asin() retorna o arco seno (em radianos) de um número, onde</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mo stretchy="false">[</mo><mrow><mo>-</mo><mn>1</mn></mrow><mo>;</mo><mn>1</mn><mo stretchy="false">]</mo><mo>,</mo><mspace width="thickmathspace"></mspace><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arcsin</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=o único valor</mo><mtext> </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tal que sin</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in [{-1};1],\;\mathtt{\operatorname{Math.asin}(x)} = \arcsin(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \sin(y) = x</annotation></semantics></math></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.asin(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O arco seno (em radianos) do parâmetro recebido se o parâmetro estiver entre <strong>-1</strong> e <strong>1</strong>; senão, {{jsxref("NaN")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Math.asin()</code> retorna um valor numérico entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> e <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianos para todo <code>x</code> entre -1 e 1. Se o valor de <code>x</code> estiver fora deste intervalo {{jsxref("NaN")}} é retornado.</p>
+
+<p>Por <code>asin()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.asin()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.asin()">Usando <code>Math.asin()</code></h3>
+
+<pre class="brush: js">Math.asin(-2);  // NaN
+Math.asin(-1);  // -1.5707963267948966 (-pi/2)
+Math.asin(0);   // 0
+Math.asin(0.5); // 0.5235987755982989
+Math.asin(1);   // 1.5707963267948966 (pi/2)
+Math.asin(2);   // NaN
+</pre>
+
+<p>Para valores menores que -1 ou maiores que 1, <code>Math.asin()</code> retorna {{jsxref("NaN")}}.</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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.3', 'Math.asin')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.asin', 'Math.asin')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.asin', 'Math.asin')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.asin")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/asinh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/asinh/index.html
new file mode 100644
index 0000000000..56c7d8a684
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/asinh/index.html
@@ -0,0 +1,97 @@
+---
+title: Math.asinh()
+slug: Web/JavaScript/Reference/Global_Objects/Math/asinh
+tags:
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/asinh
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.asinh()</code></strong> retorna o arco-seno hiperbólico de um número, isto é:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.asinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arsinh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">sinh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.asinh}(x)} = \operatorname{arsinh}(x) = \text{o} \; y \; \text{único tal que} \; \sinh(y) = x</annotation></semantics></math></p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-asinh.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.asinh(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O arco-seno hiperbólico de um dado número.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Como <code>asinh()</code> é um métodos estático de <code>Math</code>, você deve sempre chamá-lo como <code>Math.asinh()</code>, ao invés de um método de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.asinh()">Usando <code>Math.asinh()</code></h3>
+
+<pre class="brush: js">Math.asinh(1);  // 0.881373587019543
+Math.asinh(0);  // 0
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Como uma solução simples a expressçao<math><semantics><annotation encoding="TeX">\operatorname {arsinh} (x) = \ln \left(x + \sqrt{x^{2} + 1} \right)</annotation></semantics></math> pode ser usada diretamente para uma emulação grosseira pela seguinte função:</p>
+
+<pre class="brush: js">Math.asinh = Math.asinh || function(x) {
+  if (x === -Infinity) {
+    return x;
+  } else {
+    return Math.log(x + Math.sqrt(x * x + 1));
+  }
+};
+</pre>
+
+<p>Apesar de formalmente correta, ela sofre de algumas problemas relacionadas à computação de ponto flutuante. Resultados precisos precisam de tratamento especial de positivos/negativos e argumentos pequenos/grandes como feitos por exemplo em em <a href="https://sourceware.org/git/?p=glibc.git;a=blob;f=sysdeps/ieee754/dbl-64/s_asinh.c">glibc</a> ou<a href="http://git.savannah.gnu.org/cgit/gsl.git/tree/sys/invhyp.c">GNU Scientific Library</a>.</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>{{SpecName('ES6', '#sec-math.asinh', 'Math.asinh')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.asinh', 'Math.asinh')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilitade_de_navegadores">Compatibilitade de navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.asinh")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.acosh()")}}</li>
+ <li>{{jsxref("Math.atanh()")}}</li>
+ <li>{{jsxref("Math.cosh()")}}</li>
+ <li>{{jsxref("Math.sinh()")}}</li>
+ <li>{{jsxref("Math.tanh()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/atan/index.html b/files/pt-br/web/javascript/reference/global_objects/math/atan/index.html
new file mode 100644
index 0000000000..91e5b4f52a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/atan/index.html
@@ -0,0 +1,104 @@
+---
+title: Math.atan()
+slug: Web/JavaScript/Reference/Global_Objects/Math/atan
+tags:
+  - JavaScript
+  - Math
+  - Method
+  - Reference
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.atan()</code></strong> retorna a arco tangente (em radianos) de um número, onde</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">arctan</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mo>∊</mo><mrow><mo>[</mo><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac><mo>;</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><mo>]</mo></mrow><mspace width="thinmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tan</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.atan}(x)} = \arctan(x) = \text{ the unique } \; y \in \left[-\frac{\pi}{2}; \frac{\pi}{2}\right] \, \text{such that} \; \tan(y) = x</annotation></semantics></math></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.atan(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O arco tangente (em radianos) do parâmetro recebido.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Math.atan()</code> retorna um valor numérico entre <math><semantics><mrow><mo>-</mo><mfrac><mi>π</mi><mn>2</mn></mfrac></mrow><annotation encoding="TeX">-\frac{\pi}{2}</annotation></semantics></math> e <math><semantics><mfrac><mi>π</mi><mn>2</mn></mfrac><annotation encoding="TeX">\frac{\pi}{2}</annotation></semantics></math> radianos.</p>
+
+<p>Por <code>atan()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.atan()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.atan()">Usando <code>Math.atan()</code></h3>
+
+<pre class="brush: js">Math.atan(1);   // 0.7853981633974483
+Math.atan(0);   // 0
+Math.atan(-0);  // -0
+
+Math.atan(Infinity); <span class="objectBox objectBox-number">  //  1.5707963267948966
+Math.atan(-Infinity);  // -1.5707963267948966
+
+</span>// The angle that the line [(0,0);(x,y)] forms with the x-axis in a Cartesian coordinate system
+Math.atan(y / x);
+</pre>
+
+<p>Talvez você queira evitar usar <strong>±</strong><code>Infinity</code> por motivos estéticos. Nesse caso, {{jsxref("Math.atan2()")}} com <code>0</code> como segundo parâmentro pode ser uma solução melhor.</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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.4', 'Math.atan')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.atan', 'Math.atan')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.atan', 'Math.atan')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.atan")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/atan2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/atan2/index.html
new file mode 100644
index 0000000000..0c3b534c88
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/atan2/index.html
@@ -0,0 +1,150 @@
+---
+title: Math.atan2()
+slug: Web/JavaScript/Reference/Global_Objects/Math/atan2
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/atan2
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.atan2()</code></strong> retorna o arco tangente do coeficiente dos argumentos passado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.atan2(<var>y</var>, <var>x</var>)</code></pre>
+
+<h3 id="Parâmentros">Parâmentros</h3>
+
+<dl>
+ <dt><code>y</code></dt>
+ <dd>Primeiro numero.</dd>
+ <dt><code>x</code></dt>
+ <dd>Segundo numero.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>O arco tagente do coegiente dos parâmetros</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>Math.atan2()</code> método retorna um valor numérico entre -π e π representando o ângulo teta entre (x, y).  Assim indo no sentido anti-horario ao ângulo, medido em radianos, entre o eixo X positivo, e o ponto<code>(x, y)</code>.Nota os argumentos para essa função: primeiro o eixo Y(ordenadas) e o eixo X(absissas) como segundo parâmetro.</p>
+
+<p><img alt="A simple diagram showing the angle returned by atan2(y, x)" src="https://mdn.mozillademos.org/files/11557/atan2.png" style="height: 300px; width: 300px;"></p>
+
+<p><code>Math.atan2()os argumentos são passados separados x e y enquanto no Math.atan() é passado a razão entre esses argumentos.</code></p>
+
+<p>Porque <code>atan2()</code> é um método estático de  <code>Math</code>, você sempre usará  <code>Math.atan2()</code>, ao inves de um objeto Math criado (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_Math.atan2()">Using <code>Math.atan2()</code></h3>
+
+<pre class="brush: js">Math.atan2(90, 15); // 1.4056476493802699
+Math.atan2(15, 90); // 0.16514867741462683
+
+Math.atan2(±0, -0);               // ±PI.
+Math.atan2(±0, +0);               // ±0.
+Math.atan2(±0, -x);               // ±PI for x &gt; 0.
+Math.atan2(±0, x);                // ±0 for x &gt; 0.
+Math.atan2(-y, ±0);               // -PI/2 for y &gt; 0.
+Math.atan2(y, ±0);                // PI/2 for y &gt; 0.
+Math.atan2(±y, -Infinity);        // ±PI for finite y &gt; 0.
+Math.atan2(±y, +Infinity);        // ±0 for finite y &gt; 0.
+Math.atan2(±Infinity, x);         // ±PI/2 for finite x.
+Math.atan2(±Infinity, -Infinity); // ±3*PI/4.
+Math.atan2(±Infinity, +Infinity); // ±PI/4.
+</pre>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.5', 'Math.atan2')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.atan2', 'Math.atan2')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.atan2', 'Math.atan2')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/atanh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/atanh/index.html
new file mode 100644
index 0000000000..0ccb86d421
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/atanh/index.html
@@ -0,0 +1,99 @@
+---
+title: Math.atanh()
+slug: Web/JavaScript/Reference/Global_Objects/Math/atanh
+tags:
+  - JavaScript
+  - Math
+  - Method
+  - Reference
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/atanh
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.atanh()</code></strong> retorna o arco tangente hiperbólico de um número, onde</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>∊</mo><mrow><mo>(</mo><mrow><mo>-</mo><mn>1</mn><mo>,</mo><mn>1</mn></mrow><mo>)</mo></mrow><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.atanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="thinmathspace">arctanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext> the unique </mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><mo lspace="0em" rspace="0em">tanh</mo><mo stretchy="false">(</mo><mi>y</mi><mo stretchy="false">)</mo><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x \in \left( -1, 1 \right), \mathtt{\operatorname{Math.atanh}(x)} = \operatorname{arctanh}(x) = \text{ the unique } \; y \; \text{such that} \; \tanh(y) = x</annotation></semantics></math></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.atanh(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>O número.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O arco tangente hiperbólico do parâmetro recebido.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por <code>atanh()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.atanh()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.atanh()">Usando <code>Math.atanh()</code></h3>
+
+<pre class="brush: js">Math.atanh(-2);  // NaN
+Math.atanh(-1);  // -Infinity
+Math.atanh(0);   // 0
+Math.atanh(0.5); // 0.5493061443340548
+Math.atanh(1);   // Infinity
+Math.atanh(2);   // NaN
+</pre>
+
+<p>For values greater than 1 or less than -1, {{jsxref("NaN")}} is returned.</p>
+
+<p>Para valores menores que -1 ou maiores que 1, {{jsxref("NaN")}} é retornado.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Para <math><semantics><mrow><mrow><mo>|</mo><mi>x</mi><mo>|</mo></mrow><mo>&lt;</mo><mn>1</mn></mrow><annotation encoding="TeX">\left|x\right| &lt; 1</annotation></semantics></math>, temos <math><semantics><mrow><mo lspace="0em" rspace="thinmathspace">artanh</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mfrac><mn>1</mn><mn>2</mn></mfrac><mo lspace="0em" rspace="0em">ln</mo><mrow><mo>(</mo><mfrac><mrow><mn>1</mn><mo>+</mo><mi>x</mi></mrow><mrow><mn>1</mn><mo>-</mo><mi>x</mi></mrow></mfrac><mo>)</mo></mrow></mrow><annotation encoding="TeX">\operatorname {artanh} (x) = \frac{1}{2}\ln \left( \frac{1 + x}{1 - x} \right)</annotation></semantics></math>, esse comportamento pode ser emulado com a seguinte função:</p>
+
+<pre class="brush: js">Math.atanh = Math.atanh || function(x) {
+  return Math.log((1+x)/(1-x)) / 2;
+};
+</pre>
+
+<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>{{SpecName('ES6', '#sec-math.atanh', 'Math.atanh')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.atanh', 'Math.atanh')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_no_navegadores">Compatibilidade no navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.atanh")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.acosh()")}}</li>
+ <li>{{jsxref("Math.asinh()")}}</li>
+ <li>{{jsxref("Math.cosh()")}}</li>
+ <li>{{jsxref("Math.sinh()")}}</li>
+ <li>{{jsxref("Math.tanh()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/cbrt/index.html b/files/pt-br/web/javascript/reference/global_objects/math/cbrt/index.html
new file mode 100644
index 0000000000..6c7ffcdf42
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/cbrt/index.html
@@ -0,0 +1,97 @@
+---
+title: Math.cbrt()
+slug: Web/JavaScript/Reference/Global_Objects/Math/cbrt
+tags:
+  - JavaScript
+  - Math
+  - Raiz Cúbica
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/cbrt
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.cbrt()</code></strong> retorna a raiz cúbica de um número, isto é</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mi>M</mi><mi>a</mi><mi>t</mi><mi>h</mi><mo>.</mo><mi>c</mi><mi>b</mi><mi>r</mi><mi>t</mi><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mroot><mi>x</mi><mn>3</mn></mroot><mo> =</mo><mtext> y, tal que</mtext><mspace width="thickmathspace"></mspace><mtext></mtext><msup><mi>y</mi><mn>3</mn></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\mathtt{Math.cbrt(x)} = \sqrt[3]{x} = \text{the unique} \; y \; \text{such that} \; y^3 = x</annotation></semantics></math></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.cbrt(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>A raiz cúbica do número fornecido.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Porque <code>cbrt()</code> é um método estático de <code>Math</code>, você sempre irá utilizar como <code>Math.cbrt()</code>, ao invés de um método de um objeto <code>Math</code> que você tenha criado (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_Math.cbrt()">Utilizando <code>Math.cbrt()</code></h3>
+
+<pre class="brush: js">Math.cbrt(NaN); // NaN
+Math.cbrt(-1); // -1
+Math.cbrt(-0); // -0
+Math.cbrt(-Infinity); // -Infinity
+Math.cbrt(0); // 0
+Math.cbrt(1); // 1
+Math.cbrt(Infinity); // Infinity
+Math.cbrt(null); // 0
+Math.cbrt(2);  // 1.2599210498948734
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Para todo <math><semantics><mrow><mi>x</mi><mo>≥</mo><mn>0</mn></mrow><annotation encoding="TeX">x \geq 0</annotation></semantics></math>, temos <math><semantics><mrow><mroot><mi>x</mi><mn>3</mn></mroot><mo>=</mo><msup><mi>x</mi><mrow><mn>1</mn><mo>/</mo><mn>3</mn></mrow></msup></mrow><annotation encoding="TeX">\sqrt[3]{x} = x^{1/3}</annotation></semantics></math>, então isto pode ser simulado pela seguinte função:</p>
+
+<pre class="brush: js">if (!Math.cbrt) {
+  Math.cbrt = function(x) {
+    var y = Math.pow(Math.abs(x), 1/3);
+    return x &lt; 0 ? -y : y;
+  };
+}
+</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-math.cbrt', 'Math.cbrt')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.cbrt', 'Math.cbrt')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<p class="hidden">A tabela de compatibilidade nesta página é gerada de dados estruturados. Se você quiser contribuir para tais dados, por favor verifique em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data </a>e nos envie um pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.cbrt")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.pow()")}}</li>
+ <li>{{jsxref("Math.sqrt()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/ceil/index.html b/files/pt-br/web/javascript/reference/global_objects/math/ceil/index.html
new file mode 100644
index 0000000000..68e48daa87
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/ceil/index.html
@@ -0,0 +1,210 @@
+---
+title: Math.ceil()
+slug: Web/JavaScript/Reference/Global_Objects/Math/ceil
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil
+---
+<div>{{JSRef("Global_Objects", "Math")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p><code><font face="Open Sans, sans-serif">A função </font><strong>Math.ceil(x)</strong></code> retorna o menor número inteiro maior ou igual a "x".</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox">Math.ceil(<em>x</em>) </pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O menor inteiro maior ou igual ao número fornecido.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Por <code>ceil</code> ser um método estático de <code>Math</code>, você sempre usará como <code>Math.ceil()</code>, e não como um método do objeto <code>Math</code> que você criou.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Using_Math.ceil" name="Example:_Using_Math.ceil">Usando <code>Math.ceil()</code></h3>
+
+<p>O exemplo a seguir mostra um exemplo de uso de <code>Math.ceil()</code>.</p>
+
+<pre class="brush:js;"><code>Math.ceil(.95);    // 1
+Math.ceil(4);      // 4
+Math.ceil(7.004);  // 8
+Math.ceil(-0.95);  // -0
+Math.ceil(-4);     // -4
+Math.ceil(-7.004); // -7</code></pre>
+
+<h3 id="Example_Decimal_adjustment" name="Example:_Decimal_adjustment">Ajuste decimal</h3>
+
+<pre class="brush:js">// Closure
+(function(){
+
+	/**
+	 * Decimal adjustment of a number.
+	 *
+	 * @param	{String}	type	The type of adjustment.
+	 * @param	{Number}	value	The number.
+	 * @param	{Integer}	exp		The exponent (the 10 logarithm of the adjustment base).
+	 * @returns	{Number}			The adjusted value.
+	 */
+	function decimalAdjust(type, value, exp) {
+		// If the exp is undefined or zero...
+		if (typeof exp === 'undefined' || +exp === 0) {
+			return Math[type](value);
+		}
+		value = +value;
+		exp = +exp;
+		// If the value is not a number or the exp is not an integer...
+		if (isNaN(value) || !(typeof exp === 'number' &amp;&amp; exp % 1 === 0)) {
+			return NaN;
+		}
+		// Shift
+		value = value.toString().split('e');
+		value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
+		// Shift back
+		value = value.toString().split('e');
+		return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
+	}
+
+	// Decimal round
+	if (!Math.round10) {
+		Math.round10 = function(value, exp) {
+			return decimalAdjust('round', value, exp);
+		};
+	}
+	// Decimal floor
+	if (!Math.floor10) {
+		Math.floor10 = function(value, exp) {
+			return decimalAdjust('floor', value, exp);
+		};
+	}
+	// Decimal ceil
+	if (!Math.ceil10) {
+		Math.ceil10 = function(value, exp) {
+			return decimalAdjust('ceil', value, exp);
+		};
+	}
+
+})();
+
+// Round
+Math.round10(55.55, -1); // 55.6
+Math.round10(55.549, -1); // 55.5
+Math.round10(55, 1); // 60
+Math.round10(54.9, 1); // 50
+Math.round10(-55.55, -1); // -55.5
+Math.round10(-55.551, -1); // -55.6
+Math.round10(-55, 1); // -50
+Math.round10(-55.1, 1); // -60
+// Floor
+Math.floor10(55.59, -1); // 55.5
+Math.floor10(59, 1); // 50
+Math.floor10(-55.51, -1); // -55.6
+Math.floor10(-51, 1); // -60
+// Ceil
+Math.ceil10(55.51, -1); // 55.6
+Math.ceil10(51, 1); // 60
+Math.ceil10(-55.59, -1); // -55.5
+Math.ceil10(-59, 1); // -50
+</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>ECMAScript 1st Edition. implementado em JavaScript 1.0</td>
+   <td>Padrão</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_Browsers">Compatibilidade dos Browsers</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>O objeto {{jsxref("Global_Objects/Math", "Math")}} pertence a.</li>
+ <li>{{jsxref("Math.abs()")}}</li>
+ <li>{{jsxref("Math.floor()")}}</li>
+ <li>{{jsxref("Math.round()")}}</li>
+ <li>{{jsxref("Math.sign()")}}</li>
+ <li>{{jsxref("Math.trunc()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/clz32/index.html b/files/pt-br/web/javascript/reference/global_objects/math/clz32/index.html
new file mode 100644
index 0000000000..c997e014ec
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/clz32/index.html
@@ -0,0 +1,179 @@
+---
+title: Math.clz32()
+slug: Web/JavaScript/Reference/Global_Objects/Math/clz32
+tags:
+  - JavaScript
+  - Math
+  - sintaxe Math.clz32()
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/clz32
+---
+<div>{{JSRef}}</div>
+
+<p>A função Math.clz32 () retorna o número de zero bit inicial na representação binária de 32 bits de um número.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-clz32.html")}}</div>
+
+<p class="hidden">A fonte para esse exemplo interativo está armazenado em um GitHub repositório. Se você desejar contribuir com o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos enie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>Math.clz32(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><var>x</var></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O número de zero bits à esquerda na representação binária de 32 bits do número fornecido.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>"<code>clz32</code>" é short para<code>CountLeadingZeroes32</code>.</p>
+
+<p>Se x não for um número, ele será convertido em um número primeiro e depois convertido em um número inteiro não assinado de 32 bits.</p>
+
+<p>Se o número inteiro não assinado de 32 bits convertido for 0, retorne 32, porque todos os bits são 0.</p>
+
+<p>Essa função é particularmente útil para sistemas que são compilados para JS, como o Emscripten.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.clz32">Usando <code>Math.clz32()</code></h3>
+
+<pre class="brush: js notranslate">Math.clz32(1);           // 31
+Math.clz32(1000);        // 22
+Math.clz32();            // 32
+
+var stuff = [NaN, Infinity, -Infinity, 0, -0, null, undefined, 'foo', {}, []];
+stuff.every(n =&gt; Math.clz32(n) == 32);  // true
+
+Math.clz32(true);        // 31
+Math.clz32(3.5);         // 30</pre>
+
+<h2 id="Contagem_dos_principais_e_mais_além">Contagem dos principais e mais além</h2>
+
+<p>No momento, não há Math.clon para "Count Leading Ones" (chamado "clon", não "clo", porque "clo" e "clz" são muito semelhantes, especialmente para pessoas que não falam inglês). No entanto, uma função clon pode ser criada facilmente, invertendo os bits de um número e passando o resultado para Math.clz32. Fazer isso funcionará porque o inverso de 1 é 0 e vice-versa. Assim, a inversão dos bits inverterá a quantidade medida de 0s (de Math.clz32), fazendo com que Math.clz32 conte o número de unidades em vez de contar o número de zeros.</p>
+
+<p>Considere a seguinte palavra de 32 bits:</p>
+
+<pre class="brush: js notranslate">var a = 32776;   // 00000000000000001000000000001000 (16 zeros à esquerda)
+Math.clz32(a);   // 16
+
+var b = ~32776;  // 11111111111111110111111111110111 (32776 inverso, 0 zeros à esquerda)
+Math.clz32(b);   // 0 (isso é igual a quantos líderes existem em um)</pre>
+
+<p>Usando essa lógica, uma função clon pode ser criada da seguinte maneira:</p>
+
+<pre class="brush: js notranslate">var clz = Math.clz32;
+function clon(integer){
+    return clz(~integer);
+}
+</pre>
+
+<p>Além disso, essa técnica pode ser estendida para criar funções inumeráveis "Contagem de zeros à direita" e funções de contagem de zeros, como mostrado abaixo. A função ctrz abaixo preenche todos os bits altos com o bit mais baixo preenchido e depois os anula para apagar todos os bits mais altos definidos, de modo que o clz possa ser usado.</p>
+
+<pre class="brush: js notranslate">var clz = Math.clz32;
+function ctrz(integer){ // contar zeros à direita
+   // 1. preencha todos os bits mais altos após o primeiro
+    integer |= integer &lt;&lt; 16;
+    integer |= integer &lt;&lt; 8;
+    integer |= integer &lt;&lt; 4;
+    integer |= integer &lt;&lt; 2;
+    integer |= integer &lt;&lt; 1;
+// 2. Agora, a inversão dos bits revela os bits mais baixos
+    return 32 - clz(~integer) |0; // `|0`garante coerção inteira
+}
+function ctron(integer){ // conta os que estão à direita
+     // Nenhum operador shift-fill-in-with-ones está disponível em
+     // JavaScript, portanto, o código abaixo é o mais rápido
+    return ctrz(~integer);
+/ * Implementação alternativa para fins demonstrativos:
+        // 1. apaga todos os bits mais altos após o primeiro zero
+       integer &amp;= (integer &lt;&lt; 16) | 0xffff;
+       integer &amp;= (integer &lt;&lt; 8 ) | 0x00ff;
+       integer &amp;= (integer &lt;&lt; 4 ) | 0x000f;
+       integer &amp;= (integer &lt;&lt; 2 ) | 0x0003;
+       integer &amp;= (integer &lt;&lt; 1 ) | 0x0001;
+      // 2. Agora, reverter os bits revela os zeros mais baixos
+       return 32 - clon(~integer) |0;
+    */
+}
+</pre>
+
+<p>Transforme essas funções auxiliares no módulo ASM.JS; então, você tem uma verdadeira obra-prima de desempenho. Situações como essas são exatamente para o que o ASM.JS foi projetado.</p>
+
+<pre class="brush: js notranslate">var countTrailsMethods = (function(stdlib, foreign, heap) {
+    "use asm";
+    var clz = stdlib.Math.clz32;
+    function ctrz(integer) { // count trailing zeros
+        integer = integer | 0; // coerce to an integer
+// 1. preencha todos os bits mais altos após o primeiro
+// ASM js, por algum motivo, não permite ^ =, &amp; = ou | =
+        integer = integer | (integer &lt;&lt; 16);
+        integer = integer | (integer &lt;&lt; 8);
+        integer = integer | (integer &lt;&lt; 4);
+        integer = integer | (integer &lt;&lt; 2);
+        integer = integer | (integer &lt;&lt; 1);
+      // 2. Agora, a inversão dos bits revela os bits mais baixos
+        return 32 - clz(~integer) |0;
+    }
+    function ctron(integer) { //contar os últimos
+        integer = integer | 0; // coagir a um número inteiro
+        return ctrz(~integer) |0;
+    }
+// infelizmente, o ASM.JS exige objetos compactos lentos:
+    return {a: ctrz, b: ctron};
+})(window, null, null);
+var ctrz = countTrailsMethods.a;
+var ctron = countTrailsMethods.b;</pre>
+
+<h2 id="Polyfill-Trecho_de_código">Polyfill-"Trecho de código"</h2>
+
+<p>O seguinte polyfill é o mais eficiente.</p>
+
+<pre class="brush: js notranslate">if (!Math.clz32) Math.clz32 = (function(log, LN2){
+  return function(x) {
+ // Seja n ToUint32 (x).
+     // Seja p o número de zero bits iniciais em
+     // a representação binária de 32 bits de n.
+     // Retornar p.
+    var asUint = x &gt;&gt;&gt; 0;
+    if (asUint === 0) {
+      return 32;
+    }
+    return 31 - (log(asUint) / LN2 | 0) |0; // the "| 0" acts like math.floor
+  };
+})(Math.log, Math.LN2);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.clz32', 'Math.clz32')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, consulte https://github.com/mdn/browser-compat-data e envie-nos uma solicitação de recebimento.</div>
+
+<p>{{Compat("javascript.builtins.Math.clz32")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math")}}</li>
+ <li>{{jsxref("Math.imul")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/cos/index.html b/files/pt-br/web/javascript/reference/global_objects/math/cos/index.html
new file mode 100644
index 0000000000..c0b0662477
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/cos/index.html
@@ -0,0 +1,102 @@
+---
+title: Math.cos()
+slug: Web/JavaScript/Reference/Global_Objects/Math/cos
+tags:
+  - Geometria
+  - JavaScript
+  - Matemática
+  - Math
+  - Trigonometría
+  - cos
+  - cosseno
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/cos
+---
+<div>{{JSRef}}</div>
+
+<p><span style="display: none;"> </span><span class="seoSummary">A função <strong><code>Math.cos()</code></strong> ,que é estatica, retorna o {{interwiki("wikipedia", "cosseno")}} de um ângulo, que deve estar em {{interwiki("wikipedia", "radianos")}}. A expressão é </span><math style="display: inline;"> <mstyle displaystyle="true"> <mfrac> <msub> <mrow> <mtext>length</mtext> </mrow> <mrow> <mrow> <mtext>adjacent</mtext> </mrow> </mrow> </msub> <msub> <mrow> <mtext>length</mtext> </mrow> <mrow> <mrow> <mtext>hypotenuse</mtext> </mrow> </mrow> </msub> </mfrac> </mstyle> </math>.<span style="display: none;"> </span></p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-cos.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.cos(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Ângulo em radianos</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O cosseno do número: x</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Math.cos()</code> é um método que retorna um número entre -1 e 1, que representa o cosseno de um ângulo.</p>
+
+<p>Já que <code>cos()</code> é um método estático de <code>Math</code>, você sempre deve usar <code>Math.cos()</code>, ao invez de criar um objeto de <code>Math</code> (<code>Math</code> não tem construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.cos()">Usando <code>Math.cos()</code></h3>
+
+<pre class="brush: js">Math.cos(0);           // 1
+Math.cos(1);           // 0.5403023058681398
+
+Math.cos(Math.PI);     // -1
+Math.cos(2 * Math.PI); // 1
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.7', 'Math.cos')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.cos', 'Math.cos')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.cos', 'Math.cos')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_Browsers">Compatibilidade dos Browsers</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.cos")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.sin()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/cosh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/cosh/index.html
new file mode 100644
index 0000000000..f6e0671abd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/cosh/index.html
@@ -0,0 +1,88 @@
+---
+title: Math.cosh()
+slug: Web/JavaScript/Reference/Global_Objects/Math/cosh
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/cosh
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.cosh()</code></strong> retorna o cosseno hiperbólico de um número, que pode ser expressada usando {{jsxref("Math.E", "constante e", "", 1)}}:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.cosh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.cosh(x)}} = \frac{e^x + e^{-x}}{2}</annotation></semantics></math></p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-cosh.html")}}</div>
+
+<p class="hidden">A fonte para este exemplo interativo está armazenada em um repositório do GitHub. Se você gostaria de contribuir com o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.cosh(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dd><strong><code>x</code></strong></dd>
+ <dd>  Um número.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O cosseno hiperbólico do número dado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por <code>cosh()</code> ser um método estático de <code>Math</code>, sempre utilize como <code>Math.cosh()</code>, ao invés de como um método de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.cosh">Usando <code>Math.cosh()</code></h3>
+
+<pre class="brush: js">Math.cosh(0);  // 1
+Math.cosh(1);  // 1.5430806348152437
+Math.cosh(-1); // 1.5430806348152437
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Isto pode ser emulado com a ajuda da função {{jsxref("Math.exp()")}}:</p>
+
+<pre class="brush: js">Math.cosh = Math.cosh || function(x) {
+  return (Math.exp(x) + Math.exp(-x)) / 2;
+}
+</pre>
+
+<p>ou usando apenas uma chamada da função {{jsxref("Math.exp()")}}:</p>
+
+<pre class="brush: js">Math.cosh = Math.cosh || function(x) {
+  var y = Math.exp(x);
+  return (y + 1 / y) / 2;
+};
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.cosh', 'Math.cosh')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<p class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você gostaria de contribuir com as informações, por favor faça um check out de <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.cosh")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Math.acosh()")}}</li>
+ <li>{{jsxref("Math.asinh()")}}</li>
+ <li>{{jsxref("Math.atanh()")}}</li>
+ <li>{{jsxref("Math.sinh()")}}</li>
+ <li>{{jsxref("Math.tanh()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/e/index.html b/files/pt-br/web/javascript/reference/global_objects/math/e/index.html
new file mode 100644
index 0000000000..36b01b0430
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/e/index.html
@@ -0,0 +1,86 @@
+---
+title: Math.E
+slug: Web/JavaScript/Reference/Global_Objects/Math/E
+tags:
+  - JavaScript
+  - Math
+  - Propriedade
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/E
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Math.E</code></strong> representa a base dos logarítmos naturais, aproximadamente 2.718.</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.E</mi></mstyle><mo>=</mo><mi>e</mi><mo>≈</mo><mn>2.718</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.E}} = e \approx 2.718</annotation></semantics></math></p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-e.html")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<div> </div>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Como <code>E</code> é uma propriedade estática de <code>Math</code>, sempre use-a como <code>Math.E</code>, ao invés de uma propriedade de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.E">Usando <code>Math.E</code></h3>
+
+<p>A seguinte função retorna o valor de <em>e</em>:</p>
+
+<pre class="brush: js">function getNapier() {
+  return Math.E;
+}
+
+getNapier(); // 2.718281828459045
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.1.1', 'Math.E')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.e', 'Math.E')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.e', 'Math.E')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Math.E")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log1p()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/exp/index.html b/files/pt-br/web/javascript/reference/global_objects/math/exp/index.html
new file mode 100644
index 0000000000..279cb1b60b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/exp/index.html
@@ -0,0 +1,109 @@
+---
+title: Math.exp()
+slug: Web/JavaScript/Reference/Global_Objects/Math/exp
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/exp
+---
+<div>
+ {{JSRef("Global_Objects", "Math")}}</div>
+<h2 id="Summary" name="Summary">Sumário</h2>
+<p>A função <code><strong>Math.exp()</strong></code> retorna <code>e<sup>x</sup></code>, onde <code>x</code> é o argumento, e <code>e</code> é a <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/E">Constante de Euler</a>, a base dos logaritmos naturais</p>
+<h2 id="Syntax" name="Syntax">Síntaxe</h2>
+<pre class="brush:js">Math.exp(x)</pre>
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+<dl>
+ <dt>
+  <code>x</code></dt>
+ <dd>
+  Um número.</dd>
+</dl>
+<h2 id="Description" name="Description">Descrição</h2>
+<p>Pelo fato de <code>exp</code> ser um método estático de <code>Math</code>, você sempre utiliza-o como <code>Math.exp()</code>, não como um método do objeto <code>Math</code> que você criou.</p>
+<h2 id="Examples" name="Examples">Exemplos</h2>
+<h3 id="Example:_Using_Math.exp" name="Example:_Using_Math.exp">Exemplo: Usando <code>Math.exp</code></h3>
+<pre class="brush:js">Math.exp(-1); // 0.36787944117144233
+Math.exp(0);  // 1
+Math.exp(1);  // 2.718281828459045</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>1ª Edição ECMAScript 1st Edition. Implementado em JavaScript 1.0</td>
+   <td>Padrão</td>
+   <td>Definição Inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.8', 'Math.exp')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.exp', 'Math.exp')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+<p>{{ CompatibilityTable() }}</p>
+<div id="compat-desktop">
+ <table class="compat-table">
+  <tbody>
+   <tr>
+    <th>Característica</th>
+    <th>Chrome</th>
+    <th>Firefox (Gecko)</th>
+    <th>Internet Explorer</th>
+    <th>Opera</th>
+    <th>Safari</th>
+   </tr>
+   <tr>
+    <td>Suporte Básico</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+   </tr>
+  </tbody>
+ </table>
+</div>
+<div id="compat-mobile">
+ <table class="compat-table">
+  <tbody>
+   <tr>
+    <th>Característica</th>
+    <th>Android</th>
+    <th>Chrome for Android</th>
+    <th>Firefox Mobile (Gecko)</th>
+    <th>IE Mobile</th>
+    <th>Opera Mobile</th>
+    <th>Safari Mobile</th>
+   </tr>
+   <tr>
+    <td>Suporte Básico</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+   </tr>
+  </tbody>
+ </table>
+</div>
+<h2 id="See_also" name="See_also">Veja também</h2>
+<ul>
+ <li>O objeto {{jsxref("Global_Objects/Math", "Math")}} ao qual ele pertence.</li>
+ <li>{{jsxref("Math.E")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/expm1/index.html b/files/pt-br/web/javascript/reference/global_objects/math/expm1/index.html
new file mode 100644
index 0000000000..0dfe3aab94
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/expm1/index.html
@@ -0,0 +1,80 @@
+---
+title: Math.expm1()
+slug: Web/JavaScript/Reference/Global_Objects/Math/expm1
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/expm1
+---
+<div>{{JSRef}}</div>
+
+<p>The <strong><code>Math.expm1()</code></strong> function returns <code>e<sup>x</sup> - 1</code>, where <code>x</code> is the argument, and {{jsxref("Math.E", "e", "", 1)}} the base of the natural logarithms.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-expm1.html")}}</div>
+
+
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox notranslate"><code>Math.expm1(<var>x</var>)</code></pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Um número representando <code>e<sup>x</sup> - 1</code>, onde <code>e</code> é {{jsxref("Math.E", "Euler's number", "", 1)}} e <code>x</code> ié o argumento.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Porque <code>expm1()</code> é um método estático de is <code>Math</code>, você sempre o usurá como <code>Math.expm1()</code>, do que como um método de um objeto <code>Math</code> que você criou (<code>Math</code> não é um contrutor).</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>This can be emulated with the help of the {{jsxref("Math.exp()")}} function:</p>
+
+<pre class="brush: js notranslate">Math.expm1 = Math.expm1 || function(x) {
+  return Math.exp(x) - 1;
+};
+</pre>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_Math.expm1">Using <code>Math.expm1()</code></h3>
+
+<pre class="brush: js notranslate">Math.expm1(-1); // -0.6321205588285577
+Math.expm1(0);  // 0
+Math.expm1(1);  // 1.718281828459045
+</pre>
+
+<h2 id="Specifications">Specifications</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.expm1', 'Math.expm1')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.expm1")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Math.E")}}</li>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log10()")}}</li>
+ <li>{{jsxref("Math.log1p()")}}</li>
+ <li>{{jsxref("Math.log2()")}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/floor/index.html b/files/pt-br/web/javascript/reference/global_objects/math/floor/index.html
new file mode 100644
index 0000000000..13dc5a0638
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/floor/index.html
@@ -0,0 +1,199 @@
+---
+title: Math.floor()
+slug: Web/JavaScript/Reference/Global_Objects/Math/floor
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/floor
+---
+<div>{{JSRef("Global_Objects", "Math")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>A função <code><strong>Math.floor(x)</strong></code> retorna o menor número inteiro dentre o número "x".</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.floor(<em>x</em>) </code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Por <code>floor</code> ser um método estático de <code>Math</code>, você sempre irá usar como <code>Math.floor()</code>,e não como método do objeto <code>Math que você criou</code>.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_Math.floor" name="Example:_Using_Math.floor">Exemplo: Usando <code>Math.floor</code></h3>
+
+<pre class="brush:js">Math.floor( 45.95); //  45
+Math.floor(-45.95); // -46
+</pre>
+
+<h3 id="Example:_Decimal_adjustment" name="Example:_Decimal_adjustment">Exemplo: Ajuste Decimal</h3>
+
+<pre class="brush:js">// Closure
+(function(){
+
+	/**
+	 * Decimal adjustment of a number.
+	 *
+	 * @param	{String}	type	The type of adjustment.
+	 * @param	{Number}	value	The number.
+	 * @param	{Integer}	exp		The exponent (the 10 logarithm of the adjustment base).
+	 * @returns	{Number}			The adjusted value.
+	 */
+	function decimalAdjust(type, value, exp) {
+		// If the exp is undefined or zero...
+		if (typeof exp === 'undefined' || +exp === 0) {
+			return Math[type](value);
+		}
+		value = +value;
+		exp = +exp;
+		// If the value is not a number or the exp is not an integer...
+		if (isNaN(value) || !(typeof exp === 'number' &amp;&amp; exp % 1 === 0)) {
+			return NaN;
+		}
+		// Shift
+		value = value.toString().split('e');
+		value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
+		// Shift back
+		value = value.toString().split('e');
+		return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
+	}
+
+	// Decimal round
+	if (!Math.round10) {
+		Math.round10 = function(value, exp) {
+			return decimalAdjust('round', value, exp);
+		};
+	}
+	// Decimal floor
+	if (!Math.floor10) {
+		Math.floor10 = function(value, exp) {
+			return decimalAdjust('floor', value, exp);
+		};
+	}
+	// Decimal ceil
+	if (!Math.ceil10) {
+		Math.ceil10 = function(value, exp) {
+			return decimalAdjust('ceil', value, exp);
+		};
+	}
+
+})();
+
+// Round
+Math.round10(55.55, -1); // 55.6
+Math.round10(55.549, -1); // 55.5
+Math.round10(55, 1); // 60
+Math.round10(54.9, 1); // 50
+Math.round10(-55.55, -1); // -55.5
+Math.round10(-55.551, -1); // -55.6
+Math.round10(-55, 1); // -50
+Math.round10(-55.1, 1); // -60
+// Floor
+Math.floor10(55.59, -1); // 55.5
+Math.floor10(59, 1); // 50
+Math.floor10(-55.51, -1); // -55.6
+Math.floor10(-51, 1); // -60
+// Ceil
+Math.ceil10(55.51, -1); // 55.6
+Math.ceil10(51, 1); // 60
+Math.ceil10(-55.59, -1); // -55.5
+Math.ceil10(-59, 1); // -50
+</pre>
+
+<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. Implemented in JavaScript 1.0</td>
+   <td>Standard</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.9', 'Math.floor')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.floor', 'Math.floor')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_Browsers">Compatibilidade dos Browsers</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>The {{jsxref("Global_Objects/Math", "Math")}} object it belongs to.</li>
+ <li>{{jsxref("Math.abs")}}</li>
+ <li>{{jsxref("Math.ceil()")}}</li>
+ <li>{{jsxref("Math.round()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/hypot/index.html b/files/pt-br/web/javascript/reference/global_objects/math/hypot/index.html
new file mode 100644
index 0000000000..b83197c861
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/hypot/index.html
@@ -0,0 +1,115 @@
+---
+title: Math.hypot()
+slug: Web/JavaScript/Reference/Global_Objects/Math/hypot
+tags:
+  - JavaScript
+  - Math
+  - Method
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/hypot
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.hypot()</code></strong> retorna a raiz quadrada do somátorio do quadrado de seus parâmetros, ou seja</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.hypot</mo><mo stretchy="false">(</mo><msub><mi>v</mi><mn>1</mn></msub><mo>,</mo><msub><mi>v</mi><mn>2</mn></msub><mo>,</mo><mo>…</mo><mo>,</mo><msub><mi>v</mi><mi>n</mi></msub><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msqrt><mrow><munderover><mo>∑</mo><mrow><mi>i</mi><mo>=</mo><mn>1</mn></mrow><mi>n</mi></munderover><msubsup><mi>v</mi><mi>i</mi><mn>2</mn></msubsup></mrow></msqrt><mo>=</mo><msqrt><mrow><msubsup><mi>v</mi><mn>1</mn><mn>2</mn></msubsup><mo>+</mo><msubsup><mi>v</mi><mn>2</mn><mn>2</mn></msubsup><mo>+</mo><mo>…</mo><mo>+</mo><msubsup><mi>v</mi><mi>n</mi><mn>2</mn></msubsup></mrow></msqrt></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.hypot}(v_1, v_2, \dots, v_n)} = \sqrt{\sum_{i=1}^n v_i^2} = \sqrt{v_1^2 + v_2^2 + \dots + v_n^2}</annotation></semantics></math></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.hypot([<var>value1</var>[, <var>value2</var>[, ...]]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>value1, value2, ...</code></dt>
+ <dd>Números.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>A raiz quadrada do somátorio do quadrado dos parâmetros recebidos. Se um ou mais argumentos não puderem ser convertidos para um número, {{jsxref("NaN")}} é retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Para calcular a hipotenusa de um triângulo retângulo, ou o módulo de um número complexo, é usada a fórmula <code>Math.sqrt(v1*v1 + v2*v2)</code> (<math><semantics><msqrt><mrow><mi>v</mi><msup><mn>1</mn><mn>2</mn></msup><mo>+</mo><mi>v</mi><msup><mn>2</mn><mn>2</mn></msup></mrow></msqrt><annotation encoding="TeX">\sqrt{v1^2 + v2^2}</annotation></semantics></math>) onde v1 e v2 são, ou os lados de um triângulo, ou a parte real e a imaginário de um número complexo. Para calcular a distância entre duas ou mais dimensões, basta adicionar mais exponenciações dentro da raiz quadrada, por exemplo <code>Math.sqrt(v1*v1 + v2*v2 + v3*v3 + v4*v4)</code> (<math><semantics><msqrt><mrow><mi>v</mi><msup><mn>1</mn><mn>2</mn></msup><mo>+</mo><mi>v</mi><msup><mn>2</mn><mn>2</mn></msup><mo>+</mo><mi>v</mi><msup><mn>3</mn><mn>2</mn></msup><mo>+</mo><mi>v</mi><msup><mn>4</mn><mn>2</mn></msup></mrow></msqrt><annotation encoding="TeX">\sqrt{v1^2 + v2^2 + v3^2 + v4^2}</annotation></semantics></math>).</p>
+
+<p>A função Math.hypot() torna esta tarefa mais rápida e mais fácil, basta executar <code>Math.hypot(v1, v2)</code> , or <code>Math.hypot(v1, v2, v3, v4, ...)</code> .</p>
+
+<p>Dessa maneira também se evita problemas se a magnitude dos seus número for muito grande. O maio número que se pode representar em um <em>double float</em> em JavasScript é <code>Number.MAX_VALUE</code> = <span style="line-height: 1.5;">1.797...e+308</span>. Se os seu números são maior que 1e154, calcular o quadrado deles resultará em <code>Infinity</code>, estragando os seus resultados. Por exemplo, <span style="line-height: 1.5;"><code>Math.sqrt(1e200*1e200 + 1e200*1e200) = Infinity</code>. Se você usar a função <code>Math.hypot()</code>, você receberá uma resposta aceitável: <code>Math.hypot(1e200, 1e200) = 1.4142...e+200</code>.</span> Isto também é verdade para número muito pequenos. <span style="line-height: 1.5;"><code>Math.sqrt(1e-200*1e-200 + 1e-200*1e-200) = 0</code>, mas </span><code><span style="line-height: 1.5;">Math.hypot(1e-200, 1e-200) = </span></code><span style="line-height: 1.5;"><code>1.4142...e-200</code> é uma boa resposta.</span></p>
+
+<div class="note">
+<p>Por <code>hypot()</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.hypot()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p>
+</div>
+
+<p>Se nenhum parâmetro for passado, o resultado é +0.</p>
+
+<p>Se um ou mais parâmetros não puderem ser convertidos para um número, o resultado será {{jsxref("NaN")}}.</p>
+
+<p>Com apenas um parâmetro, <code>Math.hypot()</code> se comporta como <code>Math.abs()</code>.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Usando_Math.hypot()">Usando <code>Math.hypot()</code></h3>
+
+<pre class="brush: js">Math.hypot(3, 4);        // 5
+Math.hypot(3, 4, 5);     // 7.0710678118654755
+Math.hypot();            // 0
+Math.hypot(NaN);         // NaN
+Math.hypot(3, 4, 'foo'); // NaN, +'foo' =&gt; NaN
+Math.hypot(3, 4, '5');   // 7.0710678118654755, +'5' =&gt; 5
+Math.hypot(-3);          // 3, the same as Math.abs(-3)
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>O comportamento de <code>Math.hypot()</code> pode ser emulado com a seguinte função:</p>
+
+<pre class="brush: js">Math.hypot = Math.hypot || function() {
+  var y = 0;
+  var length = arguments.length;
+
+  for (var i = 0; i &lt; length; i++) {
+    if (arguments[i] === Infinity || arguments[i] === -Infinity) {
+      return Infinity;
+    }
+    y += arguments[i] * arguments[i];
+  }
+  return Math.sqrt(y);
+};
+</pre>
+
+<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>{{SpecName('ES2015', '#sec-math.hypot', 'Math.hypot')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.hypot', 'Math.hypot')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_no_navegador">Compatibilidade no navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.hypot")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Math.abs()")}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+ <li>{{jsxref("Math.sqrt()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/index.html b/files/pt-br/web/javascript/reference/global_objects/math/index.html
new file mode 100644
index 0000000000..47bbf2f3cb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/index.html
@@ -0,0 +1,208 @@
+---
+title: Math
+slug: Web/JavaScript/Reference/Global_Objects/Math
+tags:
+  - JavaScript
+  - Math
+  - NeedsTranslation
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Global_Objects/Math
+---
+<div>{{JSRef("Global_Objects", "Math")}}</div>
+
+<p><strong>Math</strong> é um objeto embutido que tem propriedades e métodos para constantes e funções matemáticas. Não é um objeto de função.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Ao contrário de outros objetos globais, <code>Math</code> não é um construtor. Todas as propriedades e métodos de <code>Math</code> são estáticos. Você pode referenciar a constante PI como <code>Math.PI</code> e você pode chamar a função de seno como <code>Math.sin(x)</code>, onde <code>x</code>  é o argumento do método. Constantes são definidas com a precisão total de números reais em JavaScript.</p>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("Math.E")}}</dt>
+ <dd>Constante de Euler e base dos logaritmos naturais, aproximadamente 2.718.</dd>
+ <dt>{{jsxref("Math.LN2")}}</dt>
+ <dd>Logaritmo natural de 2, aproximadamente 0.693.</dd>
+ <dt>{{jsxref("Math.LN10")}}</dt>
+ <dd>Logaritmo natural de 10, aproximadamente 2.303.</dd>
+ <dt>{{jsxref("Math.LOG2E")}}</dt>
+ <dd>Logaritmo de E na base 2, aproximadamente 1.443.</dd>
+ <dt>{{jsxref("Math.LOG10E")}}</dt>
+ <dd>Logaritmo de E na base 10, aproximadamente 0.434.</dd>
+ <dt>{{jsxref("Math.PI")}}</dt>
+ <dd>Relação entre a circunferência de um círculo e o seu diâmetro, aproximadamente 3.14159.</dd>
+ <dt>{{jsxref("Math.SQRT1_2")}}</dt>
+ <dd>Raiz quadrada de 1/2; Equivale a 1 dividido pela raiz quadrada de 2, aproximadamente 0.707.</dd>
+ <dt>{{jsxref("Math.SQRT2")}}</dt>
+ <dd>Raiz quadrada de 2, aproximadamente 1.414.</dd>
+</dl>
+
+<div>{{ jsOverrides("Object", "properties", "E", "LN2", "LN10", "LOG2E", "LOG10E", "PI", "SQRT1_2", "SQRT") }}</div>
+
+<h2 id="Methods" name="Methods">Métodos</h2>
+
+<div class="note">Note que as funções trigonométricas (sin(), cos(), tan(), asin(), acos(), atan(), atan2()) recebem ou retornam ângulos em radianos. Divida por (<code>Math.PI/180</code>) para converter radianos em graus, ou multiplique por esse valor para fazer a conversão inversa.</div>
+
+<dl>
+ <dt>{{jsxref("Global_Objects/Math/abs", "Math.abs(x)")}}</dt>
+ <dd>Retorna o módulo, ou valor absoluto, de um número (<math><semantics><mrow><mo stretchy="false">|</mo><mi>x</mi><mo stretchy="false">|</mo></mrow><annotation encoding="TeX">|x|</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/acos", "Math.acos(x)")}}</dt>
+ <dd>Retorna o arco-coseno de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">arccos</mo><mi>x</mi></mrow><annotation encoding="TeX">\arccos{x}</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/acosh", "Math.acosh(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o arco-coseno hiperbólico de um número.</dd>
+ <dt>{{jsxref("Global_Objects/Math/asin", "Math.asin(x)")}}</dt>
+ <dd>Retorna o arco-seno de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">arcsin</mo><mi>x</mi></mrow><annotation encoding="TeX">\arcsin{x}</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/asinh", "Math.asinh(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o arco-seno hiperbólico de um número.</dd>
+ <dt>{{jsxref("Global_Objects/Math/atan", "Math.atan(x)")}}</dt>
+ <dd>Retorna o arco-tangente de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">arctan</mo><mi>x</mi></mrow><annotation encoding="TeX">\arctan{x}</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/atanh", "Math.atanh(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o arco-tangente hiperbólico de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">arctan</mo><mi>x</mi></mrow><annotation encoding="TeX">\arctan{x}</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/atan2", "Math.atan2(x, y)")}}</dt>
+ <dd>Retorna o arco-tangente do quociente de seus argumentos.</dd>
+ <dt>{{jsxref("Global_Objects/Math/cbrt", "Math.cbrt(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna a raiz cúbica de um número (<math><semantics><mroot><mi>x</mi><mn>3</mn></mroot><annotation encoding="TeX">\root{3}{x}</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/ceil", "Math.ceil(x)")}}</dt>
+ <dd>Retorna o menor inteiro que é maior ou igual a um número.</dd>
+ <dt>{{jsxref("Global_Objects/Math/cos", "Math.cos(x)")}}</dt>
+ <dd>Retorna o coseno de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">cos</mo><mi>x</mi></mrow><annotation encoding="TeX">\cos{x}</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/cosh", "Math.cosh(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o coseno hiperbólico de um número .</dd>
+ <dt>{{jsxref("Global_Objects/Math/exp", "Math.exp(x)")}}</dt>
+ <dd>Retorna <math><semantics><msup><mi>e</mi><mi>x</mi></msup><annotation encoding="TeX">e^x</annotation></semantics></math>, onde <var>x</var> é o argumento, e <math><semantics><mi>e</mi><annotation encoding="TeX">e</annotation></semantics></math> é a constante de Euler (2.718...), a base do logaritmo natural.</dd>
+ <dt>{{jsxref("Global_Objects/Math/expm1", "Math.expm1(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna <math><semantics><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><mn>1</mn></mrow><annotation encoding="TeX">e^x-1</annotation></semantics></math>.</dd>
+ <dt>{{jsxref("Global_Objects/Math/floor", "Math.floor(x)")}}</dt>
+ <dd>Retorna o maior inteiro que é menor ou igual a um número.</dd>
+ <dt>{{jsxref("Global_Objects/Math/fround", "Math.fround(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna a mais próxima representação de ponto flutuante de <a href="http://en.wikipedia.org/wiki/Single_precision" title="link to the wikipedia page on single precision">precisão-única</a> de um número.</dd>
+ <dt>{{jsxref("Global_Objects/Math/hypot", "Math.hypot([x[,y[,…]]])")}} {{experimental_inline}}</dt>
+ <dd>Retorna a raiz quadrada da soma dos quadrados dos argumentos (<math><semantics><msqrt><mrow><msup><mi>x</mi><mn>2</mn></msup><mo>+</mo><msup><mi>y</mi><mn>2</mn></msup><mo>+</mo><mo>…</mo></mrow></msqrt><annotation encoding="TeX">\sqrt{x^2 + y^2 + \dots}</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/imul", "Math.imul(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o resultado de uma multiplicação de inteiro de 32-bit.</dd>
+ <dt>{{jsxref("Global_Objects/Math/log", "Math.log(x)")}}</dt>
+ <dd>Retorna o logaritmo natural (<math><semantics><mrow><msub><mo lspace="0em" rspace="0em">log</mo><mi>e</mi></msub><mi>x</mi></mrow><annotation encoding="TeX">\log_ex</annotation></semantics></math> ou <math><semantics><mrow><mo lspace="0em" rspace="0em">ln</mo><mi>x</mi></mrow><annotation encoding="TeX">\ln{x}</annotation></semantics></math>) de um número.</dd>
+ <dt>{{jsxref("Global_Objects/Math/log1p", "Math.log1p(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o logaritmo natural de 1 + x (<math><semantics><mrow><msub><mo lspace="0em" rspace="0em">log</mo><mi>e</mi></msub><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\log_e(1+x)</annotation></semantics></math> ou <math><semantics><mrow><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\ln(1+x)</annotation></semantics></math>) de um número.</dd>
+ <dt>{{jsxref("Global_Objects/Math/log10", "Math.log10(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o logaritmo de x na base 10 (<math><semantics><mrow><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mi>x</mi></mrow><annotation encoding="TeX">\log_{10}x</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/log2", "Math.log2(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o logaritmo de x na base 2 (<math><semantics><mrow><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mi>x</mi></mrow><annotation encoding="TeX">\log_2 x</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/max", "Math.max([x[,y[,…]]])")}}</dt>
+ <dd>Retorna o maior dentre os parâmetros recebidos.</dd>
+ <dt>{{jsxref("Global_Objects/Math/min", "Math.min([x[,y[,…]]])")}}</dt>
+ <dd>Retorna o menor dentre os parâmetros recebidos.</dd>
+ <dt>{{jsxref("Global_Objects/Math/pow", "Math.pow(x,y)")}}</dt>
+ <dd>Retorna a base <code>x</code> elevada à potência <code>y</code> do expoente, ou seja, <math><semantics><msup><mi>x</mi><mi>y</mi></msup><annotation encoding="TeX">x^y</annotation></semantics></math>.</dd>
+ <dt>{{jsxref("Global_Objects/Math/random", "Math.random()")}}</dt>
+ <dd>Retorna um número pseudo-aleatório entre 0 e 1.</dd>
+ <dt>{{jsxref("Global_Objects/Math/round", "Math.round(x)")}}</dt>
+ <dd>Retorna o valor arrendodado de <code>x</code>, para o valor inteiro mais próximo.</dd>
+ <dt>{{jsxref("Global_Objects/Math/sign", "Math.sign(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o sinal de <code>x</code>, indicando se é positivo, negativo ou zero.</dd>
+ <dt>{{jsxref("Global_Objects/Math/sin", "Math.sin(x)")}}</dt>
+ <dd>Retorna o seno de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">sin</mo><mi>x</mi></mrow><annotation encoding="TeX">\sin x</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/sinh", "Math.sinh(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna o seno hiperbólico de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><annotation encoding="TeX">\sinh x</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/sqrt", "Math.sqrt(x)")}}</dt>
+ <dd>Retorna a raiz quadrada positiva de um número (<math><semantics><msqrt><mi>x</mi></msqrt><annotation encoding="TeX">\sqrt x</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/tan", "Math.tan(x)")}}</dt>
+ <dd>Retorna a tangente de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">tan</mo><mi>x</mi></mrow><annotation encoding="TeX">\tan x</annotation></semantics></math>).</dd>
+ <dt>{{jsxref("Global_Objects/Math/tanh", "Math.tanh(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna a tangente hiperbólica de um número (<math><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi></mrow><annotation encoding="TeX">\tanh x</annotation></semantics></math>).</dd>
+ <dt><code>Math.toSource()</code> {{Non-standard_inline() }}</dt>
+ <dd>Retorna a string <code>"Math"</code>.</dd>
+ <dt>{{jsxref("Global_Objects/Math/trunc", "Math.trunc(x)")}} {{experimental_inline}}</dt>
+ <dd>Retorna a parte inteira de <code>x</code>, removendo quaisquer dígitos fracionários.</dd>
+</dl>
+
+<div>{{ jsOverrides("Object", "Methods") }}</div>
+
+<div>
+<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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial, implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8', 'Math')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math-object', 'Math')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Novos métodos adicionados: {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} e {{jsxref("Math.clz32()", "clz32()")}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Conteúdo</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Conteúdo</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number")}}</li>
+</ul>
+</div>
+
+<p> </p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/ln10/index.html b/files/pt-br/web/javascript/reference/global_objects/math/ln10/index.html
new file mode 100644
index 0000000000..a5df5d4e52
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/ln10/index.html
@@ -0,0 +1,121 @@
+---
+title: Math.LN10
+slug: Web/JavaScript/Reference/Global_Objects/Math/LN10
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN10
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Math.LN10</code></strong> representa o logaritmo natural de 10, aproximadamente 2.302:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN10</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>10</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>2.302</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN10}} = \ln(10) \approx 2.302</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Como <code>LN10</code> é uma propriedade estática de <code>Math</code>,  você sempre deve usa-lo como <code>Math.LN10</code>, ao invés de uma propriedade do objeto <code>Math</code> que você tenha criado (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.LN10">Usando <code>Math.LN10</code></h3>
+
+<p>A seguinte função retorna o log natural de 10:</p>
+
+<pre class="brush:js">function getNatLog10() {
+  return Math.LN10;
+}
+
+getNatLog10(); // 2.302585092994046
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.1.2', 'Math.LN10')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.ln10', 'Math.LN10')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.ln10', 'Math.LN10')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log10()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/ln2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/ln2/index.html
new file mode 100644
index 0000000000..dd6282bae3
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/ln2/index.html
@@ -0,0 +1,80 @@
+---
+title: Math.LN2
+slug: Web/JavaScript/Reference/Global_Objects/Math/LN2
+tags:
+  - JavaScript
+  - Math
+  - Property
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/LN2
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Math.LN2</code></strong> representa o logaritmo natural (também conhecido como logaritmo neperiano) de 2, que é aproximadamente 0.693:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LN2</mi></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>2</mn><mo stretchy="false">)</mo><mo>≈</mo><mn>0.693</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LN2}} = \ln(2) \approx 0.693</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por <code>LN2</code> ser uma propriedade estática de <code>Math</code>, deve-se sempre usá-la como <code>Math.LN2</code>, e não como uma propriedade de um objeto <code>Math</code> que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.LN2">Usando <code>Math.LN2</code></h3>
+
+<p>A função a seguir retorna o logaritmo natural de 2:</p>
+
+<pre class="brush:js">function getNatLog2() {
+  return Math.LN2;
+}
+
+getNatLog2(); // 0.6931471805599453
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.1.3', 'Math.LN2')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.ln2', 'Math.LN2')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.ln2', 'Math.LN2')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.LN2")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log2()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log/index.html
new file mode 100644
index 0000000000..21c9e18e78
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/log/index.html
@@ -0,0 +1,148 @@
+---
+title: Math.log()
+slug: Web/JavaScript/Reference/Global_Objects/Math/log
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/log
+---
+<div>{{JSRef}}</div>
+
+<p>A função  <strong><code>Math.log()</code></strong> retorna o logaritmo natural(base {{jsxref("Math.E", "e")}}) de um número, que é:</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mi>e</mi><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x &gt; 0, \mathtt{\operatorname{Math.log}(x)} = \ln(x) = \text{the unique} \; y \; \text{such that} \; e^y = x</annotation></semantics></math></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.log(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>O logaritmo natural (base {{jsxref("Math.E", "e")}}) de um número dado. Se o número é negativo, {{jsxref("NaN")}} é retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se o valor de  <code>x</code> é negativo, o retorno será sempre {{jsxref("NaN")}}.</p>
+
+<p>Por <code>log()</code> ser um método estático de <code>Math</code>, você sempre o usará como <code>Math.log()</code>, ao invés de um método de um objeto de <code> Math</code> que você criou(<code>Math</code> não é um construtor).</p>
+
+<p>Caso você precise do logaritmo natural de 2 ou 10, use as constantes {{jsxref("Math.LN2")}} ou {{jsxref("Math.LN10")}} .  Caso você precise de um logaritmo de base 2 ou 10, use {{jsxref("Math.log2()")}} ou {{jsxref("Math.log10()")}} .  Caso você precise utilizar logaritmo de outras bases, use Math.log(x) / Math.log(outraBase) como no exemplo abaixo; talvez você queira pré-calcular 1 / Math.log(outraBase) .</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.log()">Usando <code>Math.log()</code></h3>
+
+<pre class="brush: js">Math.log(-1); // NaN, out of range
+Math.log(0);  // -Infinity
+Math.log(1);  // 0
+Math.log(10); // 2.302585092994046
+</pre>
+
+<h3 id="Usando_Math.log()_como_uma_base_diferente">Usando <code>Math.log()</code> como uma base diferente</h3>
+
+<p>As funções a seguir retornam o logaritmo de <code>y</code> na base <code>x</code> (ie. <math><semantics><mrow><msub><mo>log</mo><mi>x</mi></msub><mi>y</mi></mrow><annotation encoding="TeX">\log_x y</annotation></semantics></math>):</p>
+
+<pre class="brush: js">function getBaseLog(x, y) {
+  return Math.log(y) / Math.log(x);
+}
+</pre>
+
+<p>Caso você execute <code>getBaseLog(10, 1000)</code> será retornado <code>2.9999999999999996</code> devido ao arredondamento de ponto-flutuante, o qual é bem próximo do retorno exato de 3.</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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.10', 'Math.log')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.log', 'Math.log')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.log', 'Math.log')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log1p()")}}</li>
+ <li>{{jsxref("Math.log10()")}}</li>
+ <li>{{jsxref("Math.log2()")}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log10/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log10/index.html
new file mode 100644
index 0000000000..560322b5d0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/log10/index.html
@@ -0,0 +1,137 @@
+---
+title: Math.log10()
+slug: Web/JavaScript/Reference/Global_Objects/Math/log10
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/log10
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.log10()</code></strong> retorna o logaritmo de base 10 de um número, que é</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log10</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mn>10</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x &gt; 0, \mathtt{\operatorname{Math.log10}(x)} = \log_10(x) = \text{the unique} \; y \; \text{such that} \; 10^y = x</annotation></semantics></math></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Math.log10(<var>x</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>O logaritmo de base 10 de um número. Caso o número seja negativo, {{jsxref("NaN")}} é retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Caso o valor de <code>x</code> seja menor que 0, então o retorno será sempre {{jsxref("NaN")}}.</p>
+
+<p>Por <code>log10()</code> ser um método estático de <code>Math</code>, você sempre o usará como <code>Math.log10()</code>, ao invés de usá-lo como método de um objeto <code>Math</code> criado (<code>Math</code> não é um construtor).</p>
+
+<p>Esta função é equivalente a Math.log(x) / Math.log(10).  Para log10(e) use a constante {{jsxref("Math.LOG10E")}} que é 1 / {{jsxref("Math.LN10")}}.  </p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.log10()">Usando <code>Math.log10()</code></h3>
+
+<pre class="brush: js">Math.log10(2);      // 0.3010299956639812
+Math.log10(1);      // 0
+Math.log10(0);      // -Infinity
+Math.log10(-2);     // NaN
+Math.log10(100000); // 5
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Isso pode ser simulado a partir da seguinte função:</p>
+
+<pre class="brush: js">Math.log10 = Math.log10 || function(x) {
+  return Math.log(x) * Math.LOG10E;
+};
+</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-math.log10', 'Math.log10')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.log10', 'Math.log10')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("38")}}</td>
+   <td>{{CompatGeckoDesktop("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("25")}}</td>
+   <td>{{CompatSafari("7.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log1p()")}}</li>
+ <li>{{jsxref("Math.log2()")}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log10e/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log10e/index.html
new file mode 100644
index 0000000000..1c2f57c178
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/log10e/index.html
@@ -0,0 +1,82 @@
+---
+title: Math.LOG10E
+slug: Web/JavaScript/Reference/Global_Objects/Math/LOG10E
+tags:
+  - JavaScript
+  - Math
+  - Property
+  - Propriedade
+  - Referece
+  - Referência(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG10E
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Math.LOG10E</code></strong> representa o logaritmo com base 10 de <code>e</code>, aproximadamente 0.434:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG10E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>10</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>0.434</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG10E}} = \log_10(e) \approx 0.434</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por <code>LOG10E</code> ser uma propriedade estática de <code>Math</code>, deve-se sempre usá-la como <code>Math.LOG10E</code>, e não como propriedade de um objeto <code>Math</code> criado por você (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.LOG10E">Usando <code>Math.LOG10E</code></h3>
+
+<p>A função a seguir retorna o logaritmo com base 10 de <code>e</code>:</p>
+
+<pre class="brush:js">function getLog10e() {
+  return Math.LOG10E;
+}
+
+getLog10e(); // 0.4342944819032518
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.1.5', 'Math.LOG10E')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.log10e', 'Math.LOG10E')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.log10e', 'Math.LOG10E')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_no_navegadores">Compatibilidade no navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.LOG10E")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log10()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log1p/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log1p/index.html
new file mode 100644
index 0000000000..b36c74ff62
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/log1p/index.html
@@ -0,0 +1,105 @@
+---
+title: Math.log1p()
+slug: Web/JavaScript/Reference/Global_Objects/Math/log1p
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Logaritmo Natural
+  - Math
+  - Math.log1p
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/log1p
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.log1p()</code></strong>  returna o logaritmo natural (base {{jsxref("Math.E", "e")}}) de 1 + um número, isto é</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mo>-</mo><mn>1</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log1p</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><mo lspace="0em" rspace="0em">ln</mo><mo stretchy="false">(</mo><mn>1</mn><mo>+</mo><mi>x</mi><mo stretchy="false">)</mo></mrow><annotation encoding="TeX">\forall x &gt; -1, \mathtt{\operatorname{Math.log1p}(x)} = \ln(1 + x)</annotation></semantics></math></p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-log1p.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.log1p(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O logaritmo natural (base {{jsxref("Math.E", "e")}}) de <strong>1</strong> mais o número fornecido. Se o número for menor que <strong>-1</strong>, {{jsxref("NaN")}} será retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Para valores muito pequenos de <em>x</em>, adicionando 1 pode reduzir ou eliminar precisão. Valores double floats costuman te dar em torno de 15 digitos de precisão no JavaScript. 1 + 1e-15 = 1.000000000000001, porém, 1 + 1e-16 = 1.000000000000000 e portanto, exatamente 1.0 naquele resultado, porque os números que passam de 15 digitos são arredondados.</p>
+
+<p>Quando você calcula log(1 + x), você obterá um resultado muito perto de x, se x for um valor pequeno (isto é, porque eles são chamados logaritmos 'naturais'). Se você calcular Math.log(1 + 1.1111111111e-15) você obterá uma resposta perto de1.1111111111e-15. Ao invés, você vai acabar obtendo o logaritmo de<span style="line-height: 1.5;"> </span><span style="line-height: 1.5;">1.00000000000000111022 (o arrendondamento é feito em binário, portanto, as vezes isso pode parecer estranho)</span><span style="line-height: 1.5;">, então você obterá o resultado</span><span style="line-height: 1.5;"> 1.11022...e-15, com somente 3 digitos corretos. Se, ao invés, você calcular  Math.log1p(</span>1.1111111111e-15<span style="line-height: 1.5;">) você terá um retorno mais preciso de 1.1111111110999995e-15 com 15 digitos corretos de precisão (na verdade 16 nesse caso).</span></p>
+
+<p>Se o valor de <code>x</code> for menor que -1, o valor retornado será sempre {{jsxref("NaN")}}.</p>
+
+<p>Por conta do <code>log1p()</code> ser um metódo estático de <code>Math</code>, você sempre chamará como <code>Math.log1p()</code>, ao invés de chamar como um método de um objeto <code>Math</code> que você tenha criado (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.log1p()">Usando <code>Math.log1p()</code></h3>
+
+<pre class="brush: js">Math.log1p(1);  // 0.6931471805599453
+Math.log1p(0);  // 0
+Math.log1p(-1); // -Infinity
+Math.log1p(-2); // NaN
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Isto pode ser implementado com a seguinte função:</p>
+
+<pre class="brush: js">Math.log1p = Math.log1p || function(x) {
+  return Math.log(1 + x);
+};
+</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('ES2015', '#sec-math.log1p', 'Math.log1p')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.log1p', 'Math.log1p')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.log1p")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.expm1()")}}</li>
+ <li>{{jsxref("Math.log10()")}}</li>
+ <li>{{jsxref("Math.log2()")}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log2/index.html
new file mode 100644
index 0000000000..1e15ab3f00
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/log2/index.html
@@ -0,0 +1,91 @@
+---
+title: Math.log2()
+slug: Web/JavaScript/Reference/Global_Objects/Math/log2
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/log2
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.log2()</code></strong> retorna o logaritmo de base 2 de um número, que é</p>
+
+<p><math display="block"><semantics><mrow><mo>∀</mo><mi>x</mi><mo>&gt;</mo><mn>0</mn><mo>,</mo><mstyle mathvariant="monospace"><mrow><mo lspace="0em" rspace="thinmathspace">Math.log2</mo><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo></mrow></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>x</mi><mo stretchy="false">)</mo><mo>=</mo><mtext>the unique</mtext><mspace width="thickmathspace"></mspace><mi>y</mi><mspace width="thickmathspace"></mspace><mtext>such that</mtext><mspace width="thickmathspace"></mspace><msup><mn>2</mn><mi>y</mi></msup><mo>=</mo><mi>x</mi></mrow><annotation encoding="TeX">\forall x &gt; 0, \mathtt{\operatorname{Math.log2}(x)} = \log_2(x) = \text{the unique} \; y \; \text{such that} \; 2^y = x</annotation></semantics></math></p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.log2(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code> Um número.</dt>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>O logaritmo de base 2 de um número. Caso o número seja negativo, {{jsxref("NaN")}} é retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Caso o valor de <code>x</code> seja menor que 0, então o retorno será sempre {{jsxref("NaN")}}.</p>
+
+<p>Por <code>log2()</code> ser um método estático de <code>Math</code>, você sempre o usará como <code>Math.log2()</code>, ao invés de usá-lo como método de um objeto  <code>Math</code> criado (<code>Math</code> não é um construtor).</p>
+
+<p>Esta função é equivalente a <code>Math.log(x)/Math.log(2)</code>.  Para log2(e) use a constante {{jsxref("Math.LOG2E")}} que é 1 / {{jsxref("Math.LN2")}}.  </p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.log2()">Usando <code>Math.log2()</code></h3>
+
+<pre class="brush: js">Math.log2(3);    // 1.584962500721156
+Math.log2(2);    // 1
+Math.log2(1);    // 0
+Math.log2(0);    // -Infinity
+Math.log2(-2);   // NaN
+Math.log2(1024); // 10
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Este Polyfill simula a função <code>Math.log2</code>. Note que é retornado um valor não prcesiso Observe que é retornado valores imprecisos em algumas entradas (like 1 &lt;&lt; 29), envolva em {{jsxref("Math.round()")}} se estiver trabalhando com máscaras de bits.</p>
+
+<pre class="brush: js">Math.log2 = Math.log2 || function(x) {
+  return Math.log(x) * Math.LOG2E;
+};
+</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('ES2015', '#sec-math.log2', 'Math.log2')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.log2', 'Math.log2')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.log2")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log10()")}}</li>
+ <li>{{jsxref("Math.log1p()")}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/log2e/index.html b/files/pt-br/web/javascript/reference/global_objects/math/log2e/index.html
new file mode 100644
index 0000000000..26669a3b45
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/log2e/index.html
@@ -0,0 +1,82 @@
+---
+title: Math.LOG2E
+slug: Web/JavaScript/Reference/Global_Objects/Math/LOG2E
+tags:
+  - JavaScript
+  - Math
+  - Property
+  - Propriedade
+  - Reference
+  - Referência(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/LOG2E
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Math.LOG2E</code></strong> representa o logaritmo com base 2 de <code>e</code>, aproximadamente 1.442:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.LOG2E</mi></mstyle><mo>=</mo><msub><mo lspace="0em" rspace="0em">log</mo><mn>2</mn></msub><mo stretchy="false">(</mo><mi>e</mi><mo stretchy="false">)</mo><mo>≈</mo><mn>1.442</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.LOG2E}} = \log_2(e) \approx 1.442</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por <code>LOG2E</code> ser uma propriedade estática de <code>Math</code>, deve-se sempre usá-la como <code>Math.LOG2E</code>, e não como propriedade de um objeto <code>Math</code> criado por você (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.LOG2E">Usando <code>Math.LOG2E</code></h3>
+
+<p>A função a seguir retorna o logaritmo com base 2 de <code>e</code>:</p>
+
+<pre class="brush: js">function getLog2e() {
+  return Math.LOG2E;
+}
+
+getLog2e(); // 1.4426950408889634
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.1.4', 'Math.LOG2E')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.log2e', 'Math.LOG2E')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.log2e', 'Math.LOG2E')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.LOG2E")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.log2()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/max/index.html b/files/pt-br/web/javascript/reference/global_objects/math/max/index.html
new file mode 100644
index 0000000000..d59b1fb583
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/max/index.html
@@ -0,0 +1,155 @@
+---
+title: Math.max()
+slug: Web/JavaScript/Reference/Global_Objects/Math/max
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/max
+---
+<div>{{JSRef("Global_Objects", "Math")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A função <code><strong>Math.max()</strong></code> retorna o maior de um ou mais números.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.max([<em>valor1</em>[,<em>valor2</em>, ...]]) </code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>valor1, valor2, ...</code></dt>
+ <dd>Números.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O maior dos números passados como argumentos. Se pelo menos um dos argumentos não puder ser convertido para um número {{jsxref("NaN")}} é retornado.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Por <code>max</code> ser um método estático em <code>Math</code>, você sempre irá usá-lo da seguinte maneira <code>Math.max()</code>, e não como um método da classe <code>Math</code> que você tenha instanciado.</p>
+
+<p>Se nenhum argumento for passado o resultado sempre será - {{jsxref("Global_Objects/Infinity", "Infinity")}}.</p>
+
+<p>Se um dos argumentos não puder ser convertido em um número, o resultado será {{jsxref("Global_Objects/NaN", "NaN")}}.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_Math.max" name="Example:_Using_Math.max">Usando <code>Math.max</code></h3>
+
+<pre class="brush: js">Math.max(10, 20);   //  20
+Math.max(-10, -20); // -10
+Math.max(-10, 20);  //  20
+</pre>
+
+<h3 id="Retornando_o_maior_elemento_de_um_array">Retornando o maior elemento de um array</h3>
+
+<p>{{jsxref("Array.prototype.reduce", "Array.reduce()")}} pode ser usada para encontrar o maior elemento em um vetor numérico, comparando cada valor:</p>
+
+<pre class="brush: js">var arr = [1, 2, 3];
+var max = arr.reduce(function(a, b) {
+  return Math.max(a, b);
+});</pre>
+
+<p>A função a seguir utiliza {{jsxref("Function.prototype.apply()")}} para encontrar o elemento de maior valor dentro do array. <code>getMaxOfArray([1,2,3])</code> é equivalente a <code>Math.max(1, 2, 3)</code>, mas você pode usar <code>getMaxOfArray</code>  em arrays construídos programaticamente e o ideal é utilizá-la somente em arrays com relativamente poucos elementos.</p>
+
+<pre class="brush:js">function getMaxOfArray(numArray) {
+    return Math.max.apply(null, numArray);
+}</pre>
+
+<p>O novo <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Spread_operator">operador spread</a> é um modo curto de se escrever a solução com <code>apply</code> para retornar o maior valor de um array.</p>
+
+<pre class="brush: js">var arr = [1, 2, 3];
+var max = Math.max(...arr);
+// max: 3</pre>
+
+<p>Entretanto, tanto spread(<code>...</code>) quanto <code>apply</code> irão ou falhar ou retornar o resultado errado caso o array tenha muitos elementos, porque eles tentam passar o array de elementos como parâmetros de funções. Veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function/apply#Usando_apply_e_funções_embutidas">usando apply e funções embutidas</a> para mais detalhes. A solução com <code>reduce</code> não apresenta esse problema.</p>
+
+<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>ECMAScript 1st Edition. Implemented in JavaScript 1.0</td>
+   <td>Standard</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-15.8.2.11', 'Math.max')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.max', 'Math.max')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>O objeto {{jsxref("Global_Objects/Math", "Math")}} pertence a.</li>
+ <li>{{jsxref("Math.min()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/min/index.html b/files/pt-br/web/javascript/reference/global_objects/math/min/index.html
new file mode 100644
index 0000000000..ee97e97ddf
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/min/index.html
@@ -0,0 +1,147 @@
+---
+title: Math.min()
+slug: Web/JavaScript/Reference/Global_Objects/Math/min
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/min
+---
+<div>
+<p>{{JSRef}}</p>
+
+<p>A função <strong><code>Math.min()</code></strong>  retorna o menor valor passado como parâmetro, ou <span class="seoSummary">{{jsxref("NaN")}}</span>  se o parâmetro não é ou não pode ser convertido para um número.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre><code>Math.min([<var>valor1</var>[, <var>valor2</var>[, ...]]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>valor1, valor2, ...</code></dt>
+ <dd>Números.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por que  <code>min()</code> é um método estático de <code>Math</code>, você sempre usa como <code>Math.min()</code>,  e não como um método de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p>
+
+<p>Se nenhum argumento for dado, o resultado é {{jsxref("Infinity")}}.</p>
+
+<p>Se pelo menos um dos argumentos não pode ser convertido para um número, o resultado é {{jsxref("NaN")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.min()">Usando <code>Math.min()</code></h3>
+
+<p><font><font>Este encontra o min de </font></font><code><font><font>x</font></font></code><font><font> e </font></font><code><font><font>y</font></font></code><font><font> e atribui a </font></font><code><font><font>z</font></font></code><font><font> </font></font>:</p>
+
+<pre>var x = 10, y = -20;
+var z = Math.min(x, y);
+</pre>
+
+<h3 id="Cortando_um_valor_com_Math.min()">Cortando um valor com <code>Math.min()</code></h3>
+
+<p><code>Math.min()</code> é muitas vezes usado para cortar um valor <font>sempre menor do que ou igual a um limite. </font><font>Por exemplo, este.</font></p>
+
+<pre>var x = f(foo);
+
+if (x &gt; boundary) {
+  x = boundary;
+}
+</pre>
+
+<p>pode ser escrita como este</p>
+
+<pre>var x = Math.min(f(foo), boundary);
+</pre>
+
+<p>{{jsxref("Math.max()")}} pode ser usado de uma maneira semelhante ao corte de um valor na outra extremidade.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table>
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estato</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.12', 'Math.min')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.min', 'Math.min')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.min', 'Math.min')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador"><font><font>Compatibilidade do navegador</font></font> </h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<table>
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>
+    <p>Suporte</p>
+
+    <p>básico</p>
+   </td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<table>
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Math.max()")}}</li>
+</ul>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/pi/index.html b/files/pt-br/web/javascript/reference/global_objects/math/pi/index.html
new file mode 100644
index 0000000000..22d97c22e9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/pi/index.html
@@ -0,0 +1,82 @@
+---
+title: Math.PI
+slug: Web/JavaScript/Reference/Global_Objects/Math/PI
+tags:
+  - JavaScript
+  - Math
+  - PI
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/PI
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Math.PI</code></strong> representa a proporção entre circunferência de um círculo com o seu diâmetro, aproximadamente 3.14159:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.PI</mi></mstyle><mo>=</mo><mi>π</mi><mo>≈</mo><mn>3.14159</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.PI}} = \pi \approx 3.14159</annotation></semantics></math></p>
+
+<p>{{EmbedInteractiveExample("pages/js/math-pi.html")}}</p>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Como <code>PI</code> é uma propriedade estática de <code>Math</code>, sempre use-a como <code>Math.PI</code>, ao invés de uma propriedade de um objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.PI">Usando <code>Math.PI</code></h3>
+
+<p>A seguinte função usa <code>Math.PI</code> para calcular a circunferência de um círculo com um dado raio.</p>
+
+<pre class="brush: js">function calcularCircunferencia(raio) {
+  return 2 * Math.PI * raio;
+}
+
+calcularCircunferencia(1);  // 6.283185307179586
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definiçao inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.1.6', 'Math.PI')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.pi', 'Math.PI')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.pi', 'Math.PI')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Math.PI")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/pow/index.html b/files/pt-br/web/javascript/reference/global_objects/math/pow/index.html
new file mode 100644
index 0000000000..0a478feb5a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/pow/index.html
@@ -0,0 +1,147 @@
+---
+title: Math.pow()
+slug: Web/JavaScript/Reference/Global_Objects/Math/pow
+tags:
+  - Função
+  - JavaScript
+  - Método(2)
+  - Referência(2)
+  - expoente
+  - potência
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/pow
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.pow()</code></strong> retorna a <em>base </em>elevada ao expoente <em>power</em>, ou seja, <code>base<sup>expoente</sup></code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.pow(<var>base</var>, <var>expoente</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>base</code></dt>
+ <dd>O número da base.</dd>
+ <dt><code>expoente</code></dt>
+ <dd>O expoente usado para elevar a <code>base</code>.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Como <code>pow()</code> é um método estático de <code>Math</code>, você sempre irá usá-lo como <code>Math.pow()</code>, ao invés de usá-lo como um método de um objeto do tipo <code>Math</code> que você tenha criado (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.pow()">Usando <code>Math.pow()</code></h3>
+
+<pre class="brush: js">// simples
+Math.pow(7, 2);    // 49
+Math.pow(7, 3);    // 343
+Math.pow(2, 10);   // 1024
+// expoentes fracionários
+Math.pow(4, 0.5);  // 2 (raiz quadrada de 4)
+Math.pow(8, 1/3);  // 2 (raiz cúbica de 8)
+Math.pow(2, 0.5);  // 1.4142135623730951 (raiz quadrada de 2)
+Math.pow(2, 1/3);  // 1.2599210498948732 (raiz cúbica de 2)
+// expoentes com sinais
+Math.pow(7, -2);   // 0.02040816326530612 == (1/7)<sup>2 </sup>== (1/49)
+Math.pow(8, -1/3); // 0.5 == (1/8)<sup>1/3</sup> == 1/2
+// bases com sinal
+Math.pow(-7, 2);   // 49 (quadrados sempre são positivos)
+Math.pow(-7, 3);   // -343 (cubos podem ser negativos conforme a base)
+Math.pow(-7, 0.5); // NaN (números negativos não tem uma raiz quadrada real)
+// devido ao fato que raízes "par" e "ímpar" são próximas,
+// e limitam a precisão de ponto flutuante,
+// bases negativas com expoentes fracionários sempre retornam NaN
+Math.pow(-7, 1/3); // NaN
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição Inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.13', 'Math.pow')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.pow', 'Math.pow')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.cbrt()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.sqrt()")}}</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation" title="Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value. The standard arithmetic operators are addition (+), subtraction (-), multiplication (*), and division (/).">Operador Exponencial</a> {{experimental_inline}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/random/index.html b/files/pt-br/web/javascript/reference/global_objects/math/random/index.html
new file mode 100644
index 0000000000..c3133554a8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/random/index.html
@@ -0,0 +1,102 @@
+---
+title: Math.random()
+slug: Web/JavaScript/Reference/Global_Objects/Math/random
+tags:
+  - JavaScript
+  - Math
+  - Method
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/random
+---
+<div>{{JSRef("Global_Objects", "Math")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A função <code><strong>Math.random()</strong></code> retorna um número pseudo-aleatório no intervalo <code>[0, 1[</code>, ou seja, de 0 (inclusivo) até, mas não incluindo, 1 (exclusivo), que depois você pode dimensionar para um intervalo desejado.  A implementação seleciona uma semente para o algoritmo de geração de números aleatórios; esta semente não pode ser escolhida ou reatribuída.</p>
+
+<div class="note">
+<p><code><strong>Math.random()</strong></code> não gera números criptograficamente seguros. Não a use para nada relacionado a segurança. Use a API Web Crypto, mais precisamente o método {{domxref("RandomSource.getRandomValues()", "window.crypto.getRandomValues()")}}.</p>
+</div>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.random()</code></pre>
+
+<h3 id="Parameters" name="Parameters">Valor retornado</h3>
+
+<p>Um número pseudo-aleatório entre 0 (inclusivo) e 1 (exclusivo).</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<p>Note que os números em JavaScript são pontos flutuantes que seguem o padrão IEEE 754 com comportamento <em>arredondar-para-o-par-mais-próximo</em>, os intervalos que serão citados nos exemplos a seguir (exceto o exemplo do <code>Math.random()</code>), não são exatas. Se limites extremamente grandes forem escolhidos (2<sup>53</sup> ou maior), em raros casos é possível que o limite superior (que seria exclusivo) seja retornado.</p>
+
+<h3 id="Gerando_um_número_aleatório_entre_0_(inclusivo)_e_1_(exclusivo)">Gerando um número aleatório entre 0 (inclusivo) e 1 (exclusivo)</h3>
+
+<pre class="brush: js">function getRandom() {
+  return Math.random();
+}</pre>
+
+<h3 id="Gerando_um_número_aleatório_entre_dois_valores">Gerando um número aleatório entre dois valores</h3>
+
+<p>Este exemplo retorna um número entre dois valores definidos. O valor retornado será maior ou igual a <code>min,</code> e menor que <code>max</code>.</p>
+
+<pre class="brush: js">function getRandomArbitrary(min, max) {
+  return Math.random() * (max - min) + min;
+}</pre>
+
+<h3 id="Gerando_um_número_inteiro_aleatório_entre_dois_valores">Gerando um número inteiro aleatório entre dois valores</h3>
+
+<p>Este exemplo retorna um número <em>inteiro</em> entre dois valores definidos. O valor não poderá ser menor que <code>min</code> (ou do próximo inteiro maior que <code>min,</code> caso <code>min</code> não seja inteiro), e será menor (mas não igual) a <code>max</code>.</p>
+
+<pre class="brush: js">function getRandomInt(min, max) {
+  min = Math.ceil(min);
+  max = Math.floor(max);
+  return Math.floor(Math.random() * (max - min)) + min;
+}</pre>
+
+<p></p>
+
+<div class="note">
+<p>Pode ser tentandor usar <code>Math.round()</code> para arredondar <code>min</code> e <code>max,</code> mas dessa maneira a aleatoriedade dos números seguiria uma distribuição não-uniforme, que talvez não seja o que você precisa.</p>
+</div>
+
+<h3 id="Gerando_um_número_inteiro_aleatório_entre_dois_valores_inclusive">Gerando um número inteiro aleatório entre dois valores, inclusive</h3>
+
+<p>A função <code>getRandomInt()</code> acima tem intervalo com o valor mínimo incluído e o máximo excluído. Mas se você precisar que a função inclua, tanto o mínimo quanto o máximo, em seus resultados? A função <code>getRandomIntInclusive()</code> abaixo faz isso.</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">getRandomIntInclusive</span><span class="punctuation token">(</span>min<span class="punctuation token">,</span> max<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  min <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">ceil</span><span class="punctuation token">(</span>min<span class="punctuation token">)</span><span class="punctuation token">;</span>
+  max <span class="operator token">=</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>max<span class="punctuation token">)</span><span class="punctuation token">;</span>
+  <span class="keyword token">return</span> Math<span class="punctuation token">.</span><span class="function token">floor</span><span class="punctuation token">(</span>Math<span class="punctuation token">.</span><span class="function token">random</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">*</span> <span class="punctuation token">(</span>max <span class="operator token">-</span> min <span class="operator token">+</span> <span class="number token">1</span><span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="operator token">+</span> min<span class="punctuation token">;</span>
+<span class="punctuation token">}</span></code></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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. JavaScript 1.0 (UNIX Only) / JavaScript 1.1 (Todas plataformas).</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.14', 'Math.random')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.random', 'Math.random')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p>{{Compat("javascript.builtins.Math.random")}}</p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/round/index.html b/files/pt-br/web/javascript/reference/global_objects/math/round/index.html
new file mode 100644
index 0000000000..5473ab29aa
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/round/index.html
@@ -0,0 +1,234 @@
+---
+title: Math.round()
+slug: Web/JavaScript/Reference/Global_Objects/Math/round
+tags:
+  - JavaScript
+  - Math
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/round
+---
+<div>{{JSRef("Global_Objects", "Math")}}</div>
+
+<h2 id="Resumo">Resumo</h2>
+
+<p>A função <code><strong>Math.round()</strong></code> retorna o valor de um número arredondado para o inteiro mais proximo.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code> Math.round(<em>x</em>) </code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>O valor de um número dado aproximado para o inteiro mais próximo</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se a parte fracionária do <font face="Courier New, Andale Mono, monospace">número</font> for maior ou igual a  0.5, o argumento x é arredondado para o próximo número inteiro acima, entretanto se a parte fracionária do <code>número</code> for menor que 0.5, então o valor de x é arredondado para o próximo número inteiro abaixo. Se a parte fracionária for exatamente igual a 0.5, o número é arredondado para o próximo inteiro na direção de +∞.</p>
+
+<p>Por <code>round</code> ser um método estático de <code>Math</code>, você sempre irá usá-lo como <code>Math.round()</code>, ao invés de usá-lo como um método da instância do objeto <code>Math</code> que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_Uso_de_Math.round">Exemplo: Uso de  <code>Math.round</code></h3>
+
+<pre class="brush:js">// Retorna o valor 20
+x = Math.round(20.49);
+
+// Retorna o valor 21
+x = Math.round(20.5);
+
+// Retorna o valor -20
+x = Math.round(-20.5);
+
+// Retorna o valor -21
+x = Math.round(-20.51);
+
+// Retorna 1 (!)
+// Note o erro de arredondamento por causa da inacurácia de aritmética de ponto flutuante
+// Compare o exemplo abaixo com Math.round10(1.005, -2)
+x = Math.round(1.005*100)/100;
+</pre>
+
+<h3 id="Exemplo_Arredondamento_decimal.">Exemplo: Arredondamento decimal.</h3>
+
+<pre class="brush:js">// Closure
+(function(){
+
+	/**
+	 * Ajuste decimal de um número.
+	 *
+	 * @param	{String}	type	O tipo de arredondamento.
+	 * @param	{Number}	value	O número a arredondar.
+	 * @param	{Integer}	exp		O expoente (o logaritmo decimal da base pretendida).
+	 * @returns	{Number}			O valor depois de ajustado.
+	 */
+	function decimalAdjust(type, value, exp) {
+		// Se exp é indefinido ou zero...
+		if (typeof exp === 'undefined' || +exp === 0) {
+			return Math[type](value);
+		}
+		value = +value;
+		exp = +exp;
+		// Se o valor não é um número ou o exp não é inteiro...
+		if (isNaN(value) || !(typeof exp === 'number' &amp;&amp; exp % 1 === 0)) {
+			return NaN;
+		}
+		// Transformando para string
+		value = value.toString().split('e');
+		value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
+		// Transformando de volta
+		value = value.toString().split('e');
+		return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
+	}
+
+	// Arredondamento decimal
+	if (!Math.round10) {
+		Math.round10 = function(value, exp) {
+			return decimalAdjust('round', value, exp);
+		};
+	}
+	// Decimal arredondado para baixo
+	if (!Math.floor10) {
+		Math.floor10 = function(value, exp) {
+			return decimalAdjust('floor', value, exp);
+		};
+	}
+	// Decimal arredondado para cima
+	if (!Math.ceil10) {
+		Math.ceil10 = function(value, exp) {
+			return decimalAdjust('ceil', value, exp);
+		};
+	}
+
+})();
+
+// Round (arredondamento)
+Math.round10(55.55, -1); // 55.6
+Math.round10(55.549, -1); // 55.5
+Math.round10(55, 1); // 60
+Math.round10(54.9, 1); // 50
+Math.round10(-55.55, -1); // -55.5
+Math.round10(-55.551, -1); // -55.6
+Math.round10(-55, 1); // -50
+Math.round10(-55.1, 1); // -60
+Math.round10(1.005, -2); // 1.01 -- compare este resultado com Math.round(1.005*100)/100 no exemplo acima
+// Floor (para baixo)
+Math.floor10(55.59, -1); // 55.5
+Math.floor10(59, 1); // 50
+Math.floor10(-55.51, -1); // -55.6
+Math.floor10(-51, 1); // -60
+// Ceil (para cima)
+Math.ceil10(55.51, -1); // 55.6
+Math.ceil10(51, 1); // 60
+Math.ceil10(-55.59, -1); // -55.5
+Math.ceil10(-59, 1); // -50
+</pre>
+
+<h3 id="Método_de_arredondamento_PHP">Método de arredondamento PHP</h3>
+
+<p>O código abaixo pode ser utilizado para adicionar sua própria versão do Math.round ao seu namespace no qual tenha um parâmetro de precisão. Diferentemente do arredondamento decimal do exemplo acima, esse método não realiza conversão de e para strings, e o parâmetro de precisão funciona da mesma maneira que PHP e Excel onde um positivo 1 seria arredondado para 1 casa decimal e -1 seria arredondado para os decimais.</p>
+
+<pre><code>var myNamespace = {};
+
+myNamespace.round = function(number, precision) {
+    var factor = Math.pow(10, precision);
+    var tempNumber = number * factor;
+    var roundedTempNumber = Math.round(tempNumber);
+    return roundedTempNumber / factor;
+};
+
+myNamespace.round(1234.5678, 1); // 1234.6
+myNamespace.round(1234.5678, -1); // 1230</code>
+</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>ECMAScript 1ª Edição. Implementado em JavaScript 1.0.</td>
+   <td>Padrão</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.15', 'Math.round')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.round', 'Math.round')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Phone</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.abs()")}}</li>
+ <li>{{jsxref("Math.ceil()")}}</li>
+ <li>{{jsxref("Math.floor()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sign/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sign/index.html
new file mode 100644
index 0000000000..03f8eed812
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/sign/index.html
@@ -0,0 +1,117 @@
+---
+title: Math.sign()
+slug: Web/JavaScript/Reference/Global_Objects/Math/sign
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/sign
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.sign()</code></strong> retorna o sinal de um número, indicando se o número é positivo, negativo ou zero.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.sign(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Se o parametro passado ao for numerico, a função irá converter o parametro em Um número.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um número representando o sinal do argumento fornecido.</p>
+
+<p>Se o argumento é um número positivo, o retorno será 1;</p>
+
+<p>Se o numero passado for negativo, o retorno será -1</p>
+
+<p>Se o argumento for um zero positivo , o retorno será +0</p>
+
+<p>Se o argumento for 0 negativo , o retorno será -0</p>
+
+<p>. Qualquer outro valor que não seja numérico (string transformada em numero por ex.), o retorno será {{jsxref("NaN")}} </p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Pela razão de <code>sign()</code> ser um método estático de <code>Math</code>, você sempre deve usá-lo como <code>Math.sign()</code>, e não como um método do objeto <code>Math</code> que você criou (<code>Math</code> não é um construtor).</p>
+
+<p>Esta função possui 5 tipos de valores retornados, <code>1</code>, <code>-1</code>, <code>0</code>, <code>-0</code>, <code>NaN</code>, que representam "número positivo", "número negativo", "zero positivo", "zero negativo" e {{jsxref("NaN")}}, respectivamente.</p>
+
+<p>O argumento passado para esta função será implicitamente convertido para o tipo <code>numérico</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.sign">Usando <code>Math.sign()</code></h3>
+
+<pre class="brush: js">Math.sign(3);     //  1
+Math.sign(-3);    // -1
+Math.sign('-3');  // -1
+Math.sign(0);     //  0
+Math.sign(-0);    // -0
+Math.sign(NaN);   // NaN
+Math.sign('foo'); // NaN
+Math.sign();      // NaN
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">if (!Math.sign) {
+  Math.sign = function(x) {
+    // Se x é NaN, o resultado é NaN.
+    // Se x é -0, o resultado é -0.
+    // Se x é +0, o resultado é +0.
+    // Se x é negativo e não -0, o resultado é -1.
+    // Se x é positivo e não +0, o resultado é +1.
+    return ((x &gt; 0) - (x &lt; 0)) || +x;
+    // Uma representação mais estética é mostrada abaixo
+    //
+    // ( (x &gt; 0) ? 1 : 0 )  // se x é positivo então mais um
+    //          +           // senão (porque não poder ser - e +)
+    // ( (x &lt; 0) ? -1 : 0 ) // se x é negativo então menos um
+    //         ||           // se x é 0, -0, NaN, ou não é um número,
+    //         +x           // Então o resultado será x, (ou) se x não é
+    //                      // um número, então converte x para número
+  };
+}
+</pre>
+
+<p>No polyfill acima, nenhuma coerção de tipo extra é necessária para tornar numéricos as expressões <code>(x &gt; 0) ou (x &lt; 0)</code> , porque subtraindo-as um do outro força uma conversão de tipo de booleano para numérico.</p>
+
+<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-math.sign', 'Math.sign')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.sign', 'Math.sign')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<p class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, por favor baixe-os do repositório  <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e encaminhe-nos uma requisição de pull.</p>
+
+<p>{{Compat("javascript.builtins.Math.sign")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.abs()")}}</li>
+ <li>{{jsxref("Math.ceil()")}}</li>
+ <li>{{jsxref("Math.floor()")}}</li>
+ <li>{{jsxref("Math.round()")}}</li>
+ <li>{{jsxref("Math.trunc()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sin/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sin/index.html
new file mode 100644
index 0000000000..3e5cdea187
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/sin/index.html
@@ -0,0 +1,92 @@
+---
+title: Math.sin()
+slug: Web/JavaScript/Reference/Global_Objects/Math/sin
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/sin
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.sin()</code></strong> retorna o seno de um número.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-sin.html")}}</div>
+
+<p class="hidden">A fonte deste exemplo interativo esta em um reposi. Se você tiver interesse em contribuir com o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.sin(<var>x</var>)</code></pre>
+
+<h3 id="Paramêtros">Paramêtros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número (dado em radianos)</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O seno de um número dado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Math.sin()</code> retorna um valor numérico entre -1 e 1, que representa o seno de um angulo dado em radianos.</p>
+
+<p>Como <code>sin()</code> é um método estático de <code>Math</code>, você sempre o usa como <code>Math.sin()</code>, ao invés de um método de um objeto Math que você criou (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.sin()">Usando <code>Math.sin()</code></h3>
+
+<pre class="brush: js">Math.sin(0);           // 0
+Math.sin(1);           // 0.8414709848078965
+
+Math.sin(Math.PI / 2); // 1
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.16', 'Math.sin')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.sin', 'Math.sin')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.sin', 'Math.sin')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.sin")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.acos()")}}</li>
+ <li>{{jsxref("Math.asin()")}}</li>
+ <li>{{jsxref("Math.atan()")}}</li>
+ <li>{{jsxref("Math.atan2()")}}</li>
+ <li>{{jsxref("Math.cos()")}}</li>
+ <li>{{jsxref("Math.tan()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sinh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sinh/index.html
new file mode 100644
index 0000000000..68f6aeb977
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/sinh/index.html
@@ -0,0 +1,96 @@
+---
+title: Math.sinh()
+slug: Web/JavaScript/Reference/Global_Objects/Math/sinh
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/sinh
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.sinh()</code></strong> retorna o seno hiperbólico de um número, que pode ser expresso usando a {{jsxref("Math.E", "constante e", "", 1)}}:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mo lspace="0em" rspace="thinmathspace">Math.sinh(x)</mo></mstyle><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mn>2</mn></mfrac></mrow><annotation encoding="TeX">\mathtt{\operatorname{Math.sinh(x)}} = \frac{e^x - e^{-x}}{2}</annotation></semantics></math></p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-sinh.html")}}</div>
+
+
+
+<h2 id="Sintáxe">Sintáxe</h2>
+
+<pre class="syntaxbox"><code>Math.sinh(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O seno hiperbólico do número dado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Como <code>sinh()</code> é um método estático de <code>Math</code>, você sempre deve usar como <code>Math.sinh()</code>, ao invés de um novo objeto instanciado <code>Math</code> (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.sinh()">Usando <code>Math.sinh()</code></h3>
+
+<pre class="brush: js">Math.sinh(0); // 0
+Math.sinh(1); // 1.1752011936438014
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Isso pode ser emulado com a ajuda da função {{jsxref("Math.exp()")}}:</p>
+
+<pre class="brush: js">Math.sinh = Math.sinh || function(x) {
+  return (Math.exp(x) - Math.exp(-x)) / 2;
+}
+</pre>
+
+<p>ou usando apenas uma chamada para a função {{jsxref("Math.exp()")}}:</p>
+
+<pre class="brush: js">Math.sinh = Math.sinh || function(x) {
+  var y = Math.exp(x);
+  return (y - 1 / y) / 2;
+}
+</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('ES2015', '#sec-math.sinh', 'Math.sinh')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.sinh', 'Math.sinh')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.sinh")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.acosh()")}}</li>
+ <li>{{jsxref("Math.asinh()")}}</li>
+ <li>{{jsxref("Math.atanh()")}}</li>
+ <li>{{jsxref("Math.cosh()")}}</li>
+ <li>{{jsxref("Math.tanh()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sqrt/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sqrt/index.html
new file mode 100644
index 0000000000..17c9f65bb4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/sqrt/index.html
@@ -0,0 +1,87 @@
+---
+title: Math.sqrt()
+slug: Web/JavaScript/Reference/Global_Objects/Math/sqrt
+tags:
+  - JavaScript
+  - Math
+  - Method
+  - Reference
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/sqrt
+---
+<div>{{JSRef("Global_Objects", "Math")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>A função <strong>Math.sqrt()</strong> retorna a raiz quadrada <span style="color: #4d4e53; line-height: 1.5;">de um número (</span><math><semantics><msqrt><mi>x</mi></msqrt><annotation encoding="TeX">\sqrt{x}</annotation></semantics></math><span style="color: #4d4e53; line-height: 1.5;">) .</span></p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.sqrt(<em>x</em>) </code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>A raiz quadrada do número recebido. Se o número for negativo, a função retornará {{jsxref("NaN")}}.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Se o valor de <code>x</code> for negativo, <code>Math.sqrt()</code> retorna {{jsxref("NaN")}}.</p>
+
+<p>Por <code>sqrt</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.sqrt()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_Math.sqrt" name="Example:_Using_Math.sqrt">Exemplo: Usando <code>Math.sqrt</code></h3>
+
+<pre class="brush:js">Math.sqrt(9); // 3
+Math.sqrt(2); // 1.414213562373095
+
+Math.sqrt(1);  // 1
+Math.sqrt(0);  // 0
+Math.sqrt(-1); // NaN</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.17', 'Math.sqrt')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.sqrt', 'Math.sqrt')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p>{{Compat("javascript.builtins.Math.sqrt")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Math.cbrt()")}}</li>
+ <li>{{jsxref("Math.exp()")}}</li>
+ <li>{{jsxref("Math.log()")}}</li>
+ <li>{{jsxref("Math.pow()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sqrt1_2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sqrt1_2/index.html
new file mode 100644
index 0000000000..5c2aa35e4a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/sqrt1_2/index.html
@@ -0,0 +1,81 @@
+---
+title: Math.SQRT1_2
+slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2
+tags:
+  - JavaScript
+  - Math
+  - Property
+  - Propriedade
+  - Reference
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT1_2
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code>Math.SQRT1_2</code> representa a raiz quadrada de <math><semantics><mfrac><mn>1</mn><mn>2</mn></mfrac><annotation encoding="TeX">\frac{1}{2}</annotation></semantics></math>, que é aproximadamente 0.707:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT1_2</mi></mstyle><mo>=</mo><msqrt><mfrac><mn>1</mn><mn>2</mn></mfrac></msqrt><mo>=</mo><mfrac><mn>1</mn><msqrt><mn>2</mn></msqrt></mfrac><mo>≈</mo><mn>0.707</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT1_2}} = \sqrt{\frac{1}{2}} = \frac{1}{\sqrt{2}} \approx 0.707</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por <code>SQRT1_2</code> ser um método estático de <code>Math</code>, deve-se sempre usá-lo como <code>Math.SQRT1_2()</code>, e não como um método de um objeto <code>Math</code> que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.SQRT1_2">Usando <code>Math.SQRT1_2</code></h3>
+
+<p>A função a seguir retorna 1 sobre a raiz quadrada de 2:</p>
+
+<pre class="brush:js">function getRoot1_2() {
+  return Math.SQRT1_2;
+}
+
+getRoot1_2(); // 0.7071067811865476
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.1.7', 'Math.SQRT1_2')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.sqrt1_2', 'Math.SQRT1_2')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.SQRT1_2")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.pow()")}}</li>
+ <li>{{jsxref("Math.sqrt()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/sqrt2/index.html b/files/pt-br/web/javascript/reference/global_objects/math/sqrt2/index.html
new file mode 100644
index 0000000000..7c8ceeaa5d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/sqrt2/index.html
@@ -0,0 +1,81 @@
+---
+title: Math.SQRT2
+slug: Web/JavaScript/Reference/Global_Objects/Math/SQRT2
+tags:
+  - JavaScript
+  - Math
+  - Property
+  - Propriedade
+  - Reference
+  - Referência(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/SQRT2
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Math.SQRT2</code></strong> representa a raiz quadrada de 2, que é aproximadamente 1.414:</p>
+
+<p><math display="block"><semantics><mrow><mstyle mathvariant="monospace"><mi>Math.SQRT2</mi></mstyle><mo>=</mo><msqrt><mn>2</mn></msqrt><mo>≈</mo><mn>1.414</mn></mrow><annotation encoding="TeX">\mathtt{\mi{Math.SQRT2}} = \sqrt{2} \approx 1.414</annotation></semantics></math></p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por <code>SQRT2</code> ser uma propriedade estática de <code>Math</code>, deve-se sempre usá-la como <code>Math.SQRT2</code>, e não como propriedade de um objeto <code>Math</code> criado por você (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Usando_Math.SQRT2">Usando <code>Math.SQRT2</code></h3>
+
+<p>A função a seguir retorna a raiz quadrada de 2:</p>
+
+<pre class="brush: js">function getRoot2() {
+  return Math.SQRT2;
+}
+
+getRoot2(); // 1.4142135623730951
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.1.8', 'Math.SQRT2')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.sqrt2', 'Math.SQRT2')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.sqrt2', 'Math.SQRT2')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.SQRT2")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.pow()")}}</li>
+ <li>{{jsxref("Math.sqrt()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/tan/index.html b/files/pt-br/web/javascript/reference/global_objects/math/tan/index.html
new file mode 100644
index 0000000000..0b0897490a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/tan/index.html
@@ -0,0 +1,111 @@
+---
+title: Math.tan()
+slug: Web/JavaScript/Reference/Global_Objects/Math/tan
+tags:
+  - JavaScript
+  - Matemática
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/tan
+---
+<div>
+ {{JSRef("Global_Objects", "Math")}}</div>
+<h2 id="Summary" name="Summary">Resumo</h2>
+<p>A função <code><strong>Math.tan()</strong></code> retorna a tangente de um número.</p>
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+<pre class="syntaxbox">Math.tan(<em>x</em>)</pre>
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+<dl>
+ <dt>
+  <code>x</code></dt>
+ <dd>
+  Um número representando um ângulo em radianos.</dd>
+</dl>
+<h2 id="Description" name="Description">Descrição</h2>
+<p>O método <code>tan</code> retorna um valor numérico que representa a tangente do ângulo.</p>
+<p>Como <code>tan</code> é um método estático de <code>Math</code>, use sempre <code>Math.tan()</code>, ao invés de um método de um objeto <code>Math</code> que você tenha criado.</p>
+<h2 id="Examples" name="Examples">Exemplos</h2>
+<h3 id="Example:_Using_Math.tan" name="Example:_Using_Math.tan">Exemplo: Usando <code>Math.tan</code></h3>
+<p>A seguinte função retorna a tangente da variável <code>x</code>:</p>
+<pre class="brush:js">function getTan(x) {
+   return Math.tan(x);
+}</pre>
+<p>Como a função <code>Math.tan()</code> trabalha com radianos, mas normalment epe mais fácil trabalhar em graus, a seguinte função aceita um valor em graus, converte-o para radianos e retorna a tangente.</p>
+<pre class="brush:js">function getTanDeg(deg) {
+   var rad = deg * Math.PI/180;
+   return Math.tan(rad);
+}
+</pre>
+<h2 id="Especificações">Especificações</h2>
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition. Implementado em JavaScript 1.0</td>
+   <td>Padrão</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.8.2.18', 'Math.tan')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-math.tan', 'Math.tan')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+<p>{{ CompatibilityTable() }}</p>
+<div id="compat-desktop">
+ <table class="compat-table">
+  <tbody>
+   <tr>
+    <th>característica</th>
+    <th>Chrome</th>
+    <th>Firefox (Gecko)</th>
+    <th>Internet Explorer</th>
+    <th>Opera</th>
+    <th>Safari</th>
+   </tr>
+   <tr>
+    <td>Suporte básico</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+   </tr>
+  </tbody>
+ </table>
+</div>
+<div id="compat-mobile">
+ <table class="compat-table">
+  <tbody>
+   <tr>
+    <th>Característica</th>
+    <th>Android</th>
+    <th>Chrome for Android</th>
+    <th>Firefox Mobile (Gecko)</th>
+    <th>IE Mobile</th>
+    <th>Opera Mobile</th>
+    <th>Safari Mobile</th>
+   </tr>
+   <tr>
+    <td>Suporte básico</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+   </tr>
+  </tbody>
+ </table>
+</div>
+<p> </p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/tanh/index.html b/files/pt-br/web/javascript/reference/global_objects/math/tanh/index.html
new file mode 100644
index 0000000000..1122f98d69
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/tanh/index.html
@@ -0,0 +1,88 @@
+---
+title: Math.tanh()
+slug: Web/JavaScript/Reference/Global_Objects/Math/tanh
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/tanh
+---
+<div>{{JSRef}}</div>
+
+<p>A função <strong><code>Math.tanh()</code></strong>  retorna a tangente hiperbólica de um número, que é:</p>
+
+<p><math display="block"><semantics><mrow><mo lspace="0em" rspace="0em">tanh</mo><mi>x</mi><mo>=</mo><mfrac><mrow><mo lspace="0em" rspace="0em">sinh</mo><mi>x</mi></mrow><mrow><mo lspace="0em" rspace="0em">cosh</mo><mi>x</mi></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>-</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow><mrow><msup><mi>e</mi><mi>x</mi></msup><mo>+</mo><msup><mi>e</mi><mrow><mo>-</mo><mi>x</mi></mrow></msup></mrow></mfrac><mo>=</mo><mfrac><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>-</mo><mn>1</mn></mrow><mrow><msup><mi>e</mi><mrow><mn>2</mn><mi>x</mi></mrow></msup><mo>+</mo><mn>1</mn></mrow></mfrac></mrow><annotation encoding="TeX">\tanh x = \frac{\sinh x}{\cosh x} = \frac {e^x - e^{-x}} {e^x + e^{-x}} = \frac{e^{2x} - 1}{e^{2x}+1}</annotation></semantics></math></p>
+
+<div>{{EmbedInteractiveExample("pages/js/math-tanh.html")}}</div>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><code>Math.tanh(<var>x</var>)</code></pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Uma tangente hiperbólica de um número dado.</p>
+
+<h2 id="Description">Description</h2>
+
+<p>Because <code>tanh()</code> is a static method of <code>Math</code>, you always use it as <code>Math.tanh()</code>, rather than as a method of a <code>Math</code> object you created (<code>Math</code> is not a constructor).</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_Math.tanh()">Using <code>Math.tanh()</code></h3>
+
+<pre class="brush: js">Math.tanh(0);        // 0
+Math.tanh(Infinity); // 1
+Math.tanh(1);        // 0.7615941559557649
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>This can be emulated with the help of the {{jsxref("Math.exp()")}} function:</p>
+
+<pre class="brush: js">Math.tanh = Math.tanh || function(x){
+    var a = Math.exp(+x), b = Math.exp(-x);
+    return a == Infinity ? 1 : b == Infinity ? -1 : (a - b) / (a + b);
+}
+</pre>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES2015', '#sec-math.tanh', 'Math.tanh')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-math.tanh', 'Math.tanh')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Math.tanh")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Math.acosh()")}}</li>
+ <li>{{jsxref("Math.asinh()")}}</li>
+ <li>{{jsxref("Math.atanh()")}}</li>
+ <li>{{jsxref("Math.cosh()")}}</li>
+ <li>{{jsxref("Math.sinh()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/math/trunc/index.html b/files/pt-br/web/javascript/reference/global_objects/math/trunc/index.html
new file mode 100644
index 0000000000..cba3259de7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/math/trunc/index.html
@@ -0,0 +1,144 @@
+---
+title: Math.trunc()
+slug: Web/JavaScript/Reference/Global_Objects/Math/trunc
+tags:
+  - Math
+  - Trunc
+translation_of: Web/JavaScript/Reference/Global_Objects/Math/trunc
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Math.trunc()</code></strong> retorna a parte inteira de um número, descartando suas casas decimais.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/math-trunc.html")}}</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Math.trunc(<var>x</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>x</code></dt>
+ <dd>Um número.</dd>
+</dl>
+
+<p> </p>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>A parte inteira de um dado número.</p>
+
+<p> </p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Diferente dos demais métodos em Math: {{jsxref("Math.floor()")}}, {{jsxref("Math.ceil()")}} e {{jsxref("Math.round()")}}, o retorno esperado da função <code>Math.trunc()</code> é simples e direto, ela apenas trunca o número passado a ela como parâmetro, removendo todas as casas decimais dele, não importando se o número é positivo ou negativo.</p>
+
+<p>Portanto, se o argumento passado for um número positivo, <code>Math.trunc()</code> será equivalente a <code>Math.floor(), <font face="Open Sans, Arial, sans-serif">caso contrário </font></code><code>Math.trunc()</code> será equivalente a <code>Math.ceil()</code>.</p>
+
+<p>O argumento passado a esse método será convertido a um tipo numérico implicitamente.</p>
+
+<p>Já que <code>trunc()</code> é um método estático em <code>Math</code>, sempre utilize <code>Math.trunc()</code>, ao invés de um método existente no objeto que você criou (<code>Math</code> não é um construtor).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Math.trunc()">Usando <code>Math.trunc()</code></h3>
+
+<pre class="brush: js">Math.trunc(13.37);    // 13
+Math.trunc(42.84);    // 42
+Math.trunc(0.123);    //  0
+Math.trunc(-0.123);   // -0
+Math.trunc('-1.123'); // -1
+Math.trunc(NaN);      // NaN
+Math.trunc('foo');    // NaN
+Math.trunc();         // NaN
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>(um<em>Polyfill</em> é um pedaço de código que o desenvolvedor pode colocar na sua página para garantir compatilibilidade do método. No exemplo abaixo, caso o navegador não tiver o método <code>trunc </code>na classe <code>Math</code>, ele será criado);</p>
+
+<pre class="brush: js">Math.trunc = Math.trunc || function(x) {
+  return x &lt; 0 ? Math.ceil(x) : Math.floor(x);
+}
+</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-math.trunc', 'Math.trunc')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome("38")}}</td>
+   <td>{{CompatGeckoDesktop("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("25")}}</td>
+   <td>{{CompatSafari("7.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Math.abs()")}}</li>
+ <li>{{jsxref("Math.ceil()")}}</li>
+ <li>{{jsxref("Math.floor()")}}</li>
+ <li>{{jsxref("Math.round()")}}</li>
+ <li>{{jsxref("Math.sign()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/nan/index.html b/files/pt-br/web/javascript/reference/global_objects/nan/index.html
new file mode 100644
index 0000000000..ff9bb79c7b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/nan/index.html
@@ -0,0 +1,125 @@
+---
+title: NaN
+slug: Web/JavaScript/Reference/Global_Objects/NaN
+translation_of: Web/JavaScript/Reference/Global_Objects/NaN
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Resumo">Resumo</h2>
+
+<p>A propriedade global <code><strong>NaN</strong></code> é um valor especial que significa <em>Not-A-Number</em> (não é um número).</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>NaN</code></pre>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><code>NaN</code> é uma propriedade do <em>objeto global</em>.</p>
+
+<p>O valor inicial de <code>NaN</code> é Not-A-Number - o mesmo valor de <code>Number.NaN</code>. Nos navegadores modernos, o <code>NaN</code> é uma propriedade somente leitura e não configurável. Mesmo quando não for este o caso, evite sobrescrevê-lo.</p>
+
+<p>Não é usual a utilização do <code>NaN</code>. Ele é retornado quando uma operação matemática falha (Math.sqrt(-1)) ou quando uma função tenta transformar uma string em inteiro (parseInt("blabla")).</p>
+
+<h3 id="Testando_um_valor_NaN">Testando um valor <code>NaN</code></h3>
+
+<p>Os operadores de igualdade (<code>==</code> e <code>===</code>) não podem ser usados para testar um valor NaN. Ao invés disso, utilize {{jsxref("Number.isNaN()")}} ou {{jsxref("Global_Objects/isNaN", "isNaN()")}}.</p>
+
+<pre class="brush: js">NaN === NaN;        // falso
+Number.NaN === NaN; // falso
+isNaN(NaN);         // verdadeiro
+isNaN(Number.NaN);  // verdadeiro
+</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ários</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial. Implementado no JavaScript 1.3</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.1.1', 'NaN')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-value-properties-of-the-global-object-nan', 'NaN')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.NaN")}}</li>
+ <li>{{jsxref("Number.isNaN()")}}</li>
+ <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/null/index.html b/files/pt-br/web/javascript/reference/global_objects/null/index.html
new file mode 100644
index 0000000000..8118dddc36
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/null/index.html
@@ -0,0 +1,125 @@
+---
+title: 'null'
+slug: Web/JavaScript/Reference/Global_Objects/null
+translation_of: Web/JavaScript/Reference/Global_Objects/null
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Resumo">Resumo</h2>
+
+<p>O valor <code>null</code> é um literal em JavaScript que representa um valor nulo ou "vazio" (p/ex: que aponta para um objeto inexistente). É um dos {{Glossary("Primitivo", "valores primitivos")}} do JavaScript.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>null </code></pre>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O valor <code>null</code> é um literal, e não uma propriedade do objeto global (como o <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined" title="/en-US/docs/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a> pode ser). O desenhos das APIs, o null as vezes é devolvido no lugar de um objeto que era esperado. Quando fizer a checagem de um valor para <code>null</code> ou <code>undefined</code>, esteja ciente das <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">diferenças entre o operador de igualdade (==) e o de igualdade estrita (===)</a> (em inglês). Uma conversão de tipos é realizada na operação de igualdade.</p>
+
+<pre class="brush: js">// foo não existe, não foi definido e jamais foi inicializado:
+&gt; foo
+"ReferenceError: foo is not defined"
+
+// foo é conhecido e existe, mas não aponta para nenhum tipo ou valor:
+&gt; var foo = null; foo
+"null"
+</pre>
+
+<h3 id="Diferenças_entre_null_e_undefined">Diferenças entre <code>null</code> e <code>undefined</code></h3>
+
+<pre class="brush: js">typeof null        // object (bug no ECMAScript, deveria ser null - <a href="#">http://2ality.com/2013/10/typeof-null.html</a>)
+typeof undefined   // undefined
+null === undefined // falso
+null  == undefined // verdadeiro
+</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ários</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-4.3.11', 'null value')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-null-value', 'null value')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/undefined", "undefined")}}</li>
+ <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/epsilon/index.html b/files/pt-br/web/javascript/reference/global_objects/number/epsilon/index.html
new file mode 100644
index 0000000000..bc10fb3285
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/epsilon/index.html
@@ -0,0 +1,69 @@
+---
+title: Number.EPSILON
+slug: Web/JavaScript/Reference/Global_Objects/Number/EPSILON
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Number
+  - Número
+  - Property
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/EPSILON
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Number.EPSILON</code></strong> representa a diferença entre 1 e o menor ponto flutuante maior que 1.</p>
+
+<p>Você não tem que criar um objeto {{jsxref("Number")}} para acessar esta propriedade estática (use <code>Number.EPSILON</code>).</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-epsilon.html")}}</div>
+
+
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A propriedade <code>EPSILON</code> tem o valor de aproximadamente <code>2.2204460492503130808472633361816E-16</code>, ou <code>2<sup>-52</sup></code>.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js notranslate">if (Number.EPSILON === undefined) {
+    Number.EPSILON = Math.pow(2, -52);
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Testando_igualdade">Testando igualdade</h3>
+
+<pre class="brush: js notranslate">x = 0.2;
+y = 0.3;
+z = 0.1;
+equal = (Math.abs(x - y + z) &lt; Number.EPSILON);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.epsilon', 'Number.EPSILON')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.EPSILON")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>O objeto {{jsxref("Number")}} que esta propriedade pertence.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/index.html b/files/pt-br/web/javascript/reference/global_objects/number/index.html
new file mode 100644
index 0000000000..a21a4264af
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/index.html
@@ -0,0 +1,221 @@
+---
+title: Número
+slug: Web/JavaScript/Reference/Global_Objects/Number
+tags:
+  - JavaScript
+  - Número
+  - Referência(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/Number
+---
+<div>{{JSRef("Global_Objects", "Number")}} </div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O objeto JavaScript <strong><code>Number</code></strong> é um objeto encapsulado que permite você trabalhar com valores numéricos. Um objeto <code>Number</code> é criado utilizando o construtor <code>Number()</code>.</p>
+
+<h2 id="Syntax" name="Syntax">Construtor</h2>
+
+<pre class="syntaxbox">new Number(value);</pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>O valor numérico do objeto sendo criado.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Os principais usos para o objeto <code>Number</code> são:</p>
+
+<ul>
+ <li>Se o objeto não pode ser convertido para um número, é retornado <code>NaN</code>.</li>
+ <li>Fora do contexo de um construtor (Ex., Sem o operador {{jsxref("Operators/new", "new")}}, <code>Number</code> pode ser utilizador para realizar uma conversão de tipo.</li>
+</ul>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("Number.EPSILON")}} {{experimental_inline}}</dt>
+ <dd>O menor intervalo entre dois números representáveis.</dd>
+ <dt>{{jsxref("Number.MAX_SAFE_INTEGER")}} {{experimental_inline}}</dt>
+ <dd>O inteiro máximo seguro em JavaScript (2<sup>53</sup> -1).</dd>
+ <dt>{{jsxref("Number.MAX_VALUE")}}</dt>
+ <dd>O maior número representável positivo.</dd>
+ <dt>{{jsxref("Number.MIN_SAFE_INTEGER")}} {{experimental_inline}}</dt>
+ <dd>O inteiro mínimo seguro em JavaScript (-(2<sup>53</sup> -1)).</dd>
+ <dt>{{jsxref("Number.MIN_VALUE")}}</dt>
+ <dd>O número mínimo representável positivo - isto é, o número positivo mais próximo de zero (sem ser zero na verdade).</dd>
+ <dt>{{jsxref("Number.NaN")}}</dt>
+ <dd>Valor especial que não é número.</dd>
+ <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt>
+ <dd>Valor especial representando infinito negativo; retornado no "overflow".</dd>
+ <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt>
+ <dd> Valor especial representando infinito; retornado no "overflow".</dd>
+ <dt>{{jsxref("Number.prototype")}}</dt>
+ <dd>Permite a adição de propriedades a um objeto Number.</dd>
+</dl>
+
+<div>{{jsOverrides("Function", "properties", "MAX_VALUE", "MIN_VALUE", "NaN", "NEGATIVE_INFINITY", "POSITIVE_INFINITY", "protoype")}}</div>
+
+<h2 id="Methods" name="Methods">Methods</h2>
+
+<dl>
+ <dt>{{jsxref("Number.isNaN()")}} {{experimental_inline}}</dt>
+ <dd>Determina se o valor passado é NaN.</dd>
+ <dt>{{jsxref("Number.isFinite()")}} {{experimental_inline}}</dt>
+ <dd>Determina se o tipo e o valor passado é um número finito.</dd>
+ <dt>{{jsxref("Number.isInteger()")}} {{experimental_inline}}</dt>
+ <dd>Determina se o tipo do valor passado é  inteiro.</dd>
+ <dt>{{jsxref("Number.isSafeInteger()")}} {{experimental_inline}}</dt>
+ <dd>Determina se o tipo do valor passado é um inteiro seguro (número entre -(2<sup>53</sup> -1) e 2<sup>53</sup> -1).</dd>
+ <dt><s class="obsoleteElement">{{jsxref("Number.toInteger()")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Usado para avaliar o valor passado e convertê-lo a um inteiro (ou infinito), mas foi removido.</s></dd>
+ <dt>{{jsxref("Number.parseFloat()")}} {{experimental_inline}}</dt>
+ <dd>O valor é o mesmo que {{jsxref("Global_Objects/parseFloat", "parseFloat")}} do objeto global.</dd>
+ <dt>{{jsxref("Number.parseInt()")}} {{experimental_inline}}</dt>
+ <dd>O valor é o mesmo que {{jsxref("Global_Objects/parseInt", "parseInt")}} do objeto global.</dd>
+</dl>
+
+<div>{{jsOverrides("Function", "methods", "isNaN")}}</div>
+
+<h2 id="Number_instances" name="Number_instances">Instâncias<code> Number</code>  </h2>
+
+<p>Toda instância <code>Number</code> herdam de {{jsxref("Number.prototype")}}. O objeto 'prototype' do construtor <code>Number</code> pode ser modificado para afetar todas as instâncias <code>Number</code>.</p>
+
+<h3 id="Methods_of_number_instance" name="Methods_of_number_instance">Métodos</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/prototype', 'Methods')}}</div>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_the_Number_object_to_assign_values_to_numeric_variables" name="Example:_Using_the_Number_object_to_assign_values_to_numeric_variables">Exemplo: Usando o objeto <code>Number</code> para atribuir valores a variáveis numéricas</h3>
+
+<p>O seguinte exemplo usa as propriedades do objeto <code>Number</code> para atribuir valores a várias variáveis numéricas:</p>
+
+<pre class="brush: js">var biggestNum = Number.MAX_VALUE;
+var smallestNum = Number.MIN_VALUE;
+var infiniteNum = Number.POSITIVE_INFINITY;
+var negInfiniteNum = Number.NEGATIVE_INFINITY;
+var notANum = Number.NaN;
+</pre>
+
+<h3 id="Example:_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object">Exemplo: Intervalo inteiro para <code>Number</code></h3>
+
+<p>O seguinte exemplo mostra os valores inteiros mínimo e máximo que podem ser representados como objeto <code>Number</code> (para mais detalhes, referir-se ao padrão EcmaScript standard (EcmaScript standard), capítulo <em>8.5 O tipo de número (The Number Type</em>):</p>
+
+<pre class="brush: js">var maxInt = 9007199254740992;
+var minInt = -9007199254740992;
+</pre>
+
+<p>Ao analisar dados que foram serializados para JSON, valores inteiros que caem fora desse intervalo podem ser corrompidos quando o analisador JSON os converte ao tipo <code>Number</code>. Usando <code>String </code>em vez disso é uma possível alternativa para se evitar um resultado indesejado.</p>
+
+<h3 id="Example:_Using_Number_to_convert_a_Date_object" name="Example:_Using_Number_to_convert_a_Date_object"><span style="display: none;"> </span>Exemplo: Usando <code>Number para converter um objeto</code> <code>Date</code></h3>
+
+<p>O exemplo a seguir converte o objeto <code>Date</code> para um valor numérico usando <code>Number como uma função</code>:</p>
+
+<pre class="brush: js">var d = new Date("December 17, 1995 03:24:00");
+print(Number(d));
+</pre>
+
+<p>Isto resulta em "819199440000".</p>
+
+<h3 id="Converte_'string'_numérica_em_números">Converte 'string' numérica em números</h3>
+
+<pre class="brush: js">Number('123')     // 123
+Number('12.3')    // 12.3
+Number('')        // 0
+Number('0x11')    // 17
+Number('0b11')    // 3
+Number('0o11')    // 9
+Number('foo')     // NaN
+Number('100a')    // NaN
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>Primeiro edição ECMAScript. Implementado em JavaScript 1.1</td>
+   <td>Padrão</td>
+   <td>definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7', 'Number')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number-objects', 'Number')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Novos métodos e propriedades adicionadas (EPSILON, isFinite, isInteger, isNaN, parseFloat, parseInt)</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/NaN", "NaN")}}</li>
+ <li>O objeto global {{jsxref("Global_Objects/Math", "Math")}}</li>
+</ul>
+
+<div id="cke_pastebin" style="position: absolute; top: 2173.92px; width: 1px; height: 1px; overflow: hidden; left: -1000px;"> </div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/isfinite/index.html b/files/pt-br/web/javascript/reference/global_objects/number/isfinite/index.html
new file mode 100644
index 0000000000..d4a86d3531
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/isfinite/index.html
@@ -0,0 +1,86 @@
+---
+title: Number.isFinite()
+slug: Web/JavaScript/Reference/Global_Objects/Number/isFinite
+tags:
+  - JavaScript
+  - Method
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Number.isFinite()</code></strong>  determina se o valor passado é um número finito.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Number.isFinite(v<var>alor</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>valor</code></dt>
+ <dd>O valor a ser testado.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se o valor passado é ou não um número finito.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Em comparação com a função global {{jsxref("isFinite", "isFinite()")}}, esse método não força a conversão do parâmetro para número. Isso significa que só valores do tipo número, que são também finitos, retornam <code>true</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">Number.isFinite(Infinity);  // false
+Number.isFinite(NaN);       // false
+Number.isFinite(-Infinity); // false
+
+Number.isFinite(0);         // true
+Number.isFinite(2e64);      // true
+
+Number.isFinite('0');       // false, teria sido true com a função
+                            // global isFinite('0')
+Number.isFinite(null);      // false, teria sido true com a função
+                            // global isFinite(null)
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">Number.isFinite = Number.isFinite || function(value) {
+    return typeof value === 'number' &amp;&amp; isFinite(value);
+}
+</pre>
+
+<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>{{SpecName('ES6', '#sec-number.isfinite', 'Number.isInteger')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.isfinite', 'Number.isInteger')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.isFinite")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>O objeto {{jsxref("Number")}} ao qual pertence.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/isinteger/index.html b/files/pt-br/web/javascript/reference/global_objects/number/isinteger/index.html
new file mode 100644
index 0000000000..fce6b5f19c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/isinteger/index.html
@@ -0,0 +1,136 @@
+---
+title: Number.isInteger()
+slug: Web/JavaScript/Reference/Global_Objects/Number/isInteger
+tags:
+  - Numérico
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Number.isInteger()</code></strong> determina se o valor passado é um inteiro.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Number.isInteger(v<var>alue</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>O valor a testar se é um inteiro.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se o valor é inteiro ou não.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se o alvo for um inteiro, returna <code>true</code>, senão returna <code>false</code>. Se o valor é {{jsxref("NaN")}} ou infinito, returna <code>false</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">Number.isInteger(0);         // true
+Number.isInteger(1);         // true
+Number.isInteger(-100000);   // true
+
+Number.isInteger(0.1);       // false
+Number.isInteger(Math.PI);   // false
+
+Number.isInteger(Infinity);  // false
+Number.isInteger(-Infinity); // false
+Number.isInteger("10");      // false
+Number.isInteger(true);      // false
+Number.isInteger(false);     // false
+Number.isInteger([1]);       // false
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) {
+  return typeof value === "number" &amp;&amp;
+    isFinite(value) &amp;&amp;
+    Math.floor(value) === value;
+};
+</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-number.isinteger', 'Number.isInteger')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.isinteger', 'Number.isInteger')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("16")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("16")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_tabém">Ver tabém</h2>
+
+<ul>
+ <li>O objeto {{jsxref("Number")}} a qual este método pertence.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/isnan/index.html b/files/pt-br/web/javascript/reference/global_objects/number/isnan/index.html
new file mode 100644
index 0000000000..9652d6628c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/isnan/index.html
@@ -0,0 +1,131 @@
+---
+title: Number.isNaN()
+slug: Web/JavaScript/Reference/Global_Objects/Number/isNaN
+tags:
+  - Experimental
+  - Expérimental(2)
+  - JavaScript
+  - Method
+  - Number
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN
+---
+<div>{{JSRef("Global_Objects", "Number")}}</div>
+
+<h2 id="Resumo">Resumo</h2>
+
+<p>O método <strong><code>Number.isNaN()</code></strong> determina se o valor passado é {{jsxref("Global_Objects/NaN", "NaN")}}. Versão mais robusta do original global {{jsxref("Global_Objects/isNaN", "isNaN")}}.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Number.isNaN(test<em>Value</em>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>test<em>Value</em></code></dt>
+ <dd>O valor a ser testado por {{jsxref("Global_Objects/NaN", "NaN")}}.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Devido a ambos os operadores de igualdade, == and ===, avaliar a <code>false</code> quando está verificando se {{jsxref("Global_Objects/NaN", "NaN")}} <em>é</em> NaN, a função <code>Number.isNaN</code> se torna necessária. Esta situação é diferente de todas as outras comparações de valor possível em JavaScript.</p>
+
+<p>Em comparação a função global {{jsxref("Global_Objects/isNaN", "isNaN")}}, Number.isNaN não sofre do problema de forçar a conversão do parâmetro para um número. Isso significa que ele é seguro para passar valores que, normalmente, se convertem em NaN, mas na verdade não são o mesmo valor que NaN. Isto também significa que apenas os valores do número do tipo, que são também NaN, retorna <code>true</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush:js;">Number.isNaN(NaN); // true
+Number.isNaN(Number.NaN); // true
+Number.isNaN(0 / 0) // true
+
+// everything else: false
+Number.isNaN(undefined);
+Number.isNaN({});
+
+Number.isNaN(true);
+Number.isNaN(null);
+Number.isNaN(37);
+
+Number.isNaN("37");
+Number.isNaN("37.37");
+Number.isNaN("");
+Number.isNaN(" ");
+Number.isNaN("NaN");
+Number.isNaN("blabla"); // e.g. este teria sido true com isNaN</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>
+    <p>{{SpecName('ES6', '#sec-number.isnan', 'Number.isnan')}}</p>
+   </td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>25.0</td>
+   <td>{{CompatGeckoDesktop("15")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th><span style="font-size: 15.5555562973022px;">Característica</span></th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td><span style="font-size: 12.222222328186px;">Suporte básico</span></td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatUnknown() }}</td>
+   <td>{{CompatGeckoMobile("15")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>O {{jsxref("Global_Objects/Number", "Number")}} objeto pertence a.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/issafeinteger/index.html b/files/pt-br/web/javascript/reference/global_objects/number/issafeinteger/index.html
new file mode 100644
index 0000000000..b6b9d823bc
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/issafeinteger/index.html
@@ -0,0 +1,104 @@
+---
+title: Number.isSafeInteger()
+slug: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
+tags:
+  - JavaScript
+  - Número
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/isSafeInteger
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Number.isSafeInteger()</code></strong> determina se o valor fornecido é seja um número seguro.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-issafeinteger.html")}}</div>
+
+
+
+<p>Um inteiro seguro é um inteiro que:</p>
+
+<ul>
+ <li>pode ser representando exatamente como um número IEEE-754 de dupla precisão e</li>
+ <li>pode ser representando exatamente como um número IEEE-754<br>
+  de precisão dupla e</li>
+ <li>cuja representação IEEE-754 não pode ser o resultado do arrendodamento de qualquer outro número inteiro para se ajustar ao IEEE-754.</li>
+</ul>
+
+<p>Exemplo, <code>2<sup>53</sup> - 1</code> é um inteiro seguro: pode ser exatamente representado, e nenhum outro numero arredondado existe para ele na represetanção IEEE-754. Em contexto, <code>2<sup>53</sup></code> <em>não</em> é um inteiro seguro: pode ser representado em IEEE-754, mas um inteiro <code>2<sup>53</sup> + 1</code> não pode ser diretamente representado em IEEE-754 mas instanciado do arrendamento de <code>2<sup>53</sup></code> sob arrendamento para o mais próximo e do arrendamento de zero a zero. Os inteiros seguros consistem em todos os inteiros de <code>-(2<sup>53</sup> - 1)</code> inclusive para <code>2<sup>53</sup> - 1</code> (sendo ± <code>9007199254740991</code> ou ± 9,007,199,254,740,991).  </p>
+
+<p>A manipulação de valores entre ~9 quadrilhões com precisão total requer o uso de <a href="https://en.wikipedia.org/wiki/Arbitrary-precision_arithmetic">arbitrary precision arithmetic library</a> (biblioteca aritmética de precisão arbitrária).  Veja <a href="http://floating-point-gui.de/">What Every Programmer Needs to Know about Floating Point Arithmetic</a> (o que todo programador precisa saber sobre aritmética de ponto flutuante) para mais informações sobre represetanções de número de ponto flutuante.</p>
+
+<p>Para números inteiros maiores, considere o uso do tipo {{jsxref("BigInt")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Number.isSafeInteger(valorTest)</code>
+</pre>
+
+<h3 id="Parâmetros"><strong>Parâmetros</strong></h3>
+
+<dl>
+ <dt><code>valorTest</code></dt>
+ <dd>O valor a ser testado pode ser um número inteiro seguro.</dd>
+ <dd></dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} indica se o valor fornecido é um número seguro ou não.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">Number.isSafeInteger(3);                    // true
+Number.isSafeInteger(Math.pow(2, 53));      // false
+Number.isSafeInteger(Math.pow(2, 53) - 1);  // true
+Number.isSafeInteger(NaN);                  // false
+Number.isSafeInteger(Infinity);             // false
+Number.isSafeInteger('3');                  // false
+Number.isSafeInteger(3.1);                  // false
+Number.isSafeInteger(3.0);                  // true
+</pre>
+
+<h2 id="Polyfill_caso_não_exista_suporte">Polyfill (caso não exista suporte)</h2>
+
+<pre class="brush: js">Number.isSafeInteger = Number.isSafeInteger || function (value) {
+   return Number.isInteger(value) &amp;&amp; Math.abs(value) &lt;= Number.MAX_SAFE_INTEGER;
+};
+</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">Coméntario</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.issafeinteger', 'Number.isSafeInteger')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.isSafeInteger")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>O objeto pertence a {{jsxref("Number")}}</li>
+ <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li>
+ <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li>
+ <li>{{jsxref("BigInt")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/max_safe_integer/index.html b/files/pt-br/web/javascript/reference/global_objects/number/max_safe_integer/index.html
new file mode 100644
index 0000000000..bae4c758f3
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/max_safe_integer/index.html
@@ -0,0 +1,83 @@
+---
+title: Number.MAX_SAFE_INTEGER
+slug: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Number
+  - Número
+  - Property
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_SAFE_INTEGER
+---
+<div>{{JSRef}}</div>
+
+<p>A constante <strong><code>Number.MAX_SAFE_INTEGER</code></strong> representa o maior inteiro seguro no JavaScript (<code>2<sup>53</sup> - 1</code>).</p>
+
+<p>Para inteiros maiores, considere usar {{jsxref("BigInt")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-maxsafeinteger.html")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A constante <code>MAX_SAFE_INTEGER</code> tem o valor de <code>9007199254740991</code> (9,007,199,254,740,991 ou ~9 quadrilhões). A razão por trás deste número é que o JavaScript usa o <a href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format">formato de número de ponto-flutuante de precisão-dupla</a> como especificado na <a href="http://en.wikipedia.org/wiki/IEEE_floating_point">IEEE 754</a> e pode seguramente representar número entre <code>-(2<sup>53</sup> - 1)</code> e <code>2<sup>53</sup> - 1</code>.</p>
+
+<p>Seguro neste contexto se refere a habilidade de representar inteiros exatamente e corretamente compará-los. Por exemplo, <code>Number.MAX_SAFE_INTEGER + 1 === Number.MAX_SAFE_INTEGER + 2</code> será avaliado para verdadeiro, que é matematicamente incorreto. Veja {{jsxref("Number.isSafeInteger()")}} para mais informação.</p>
+
+<p>Este campo não existe em navegadores antigos. Usando ele sem checar sua existência, como <code>Math.max(Number.MAX_SAFE_INTEGER, 2)</code>, irá gerar resultados indesejados como NaN.</p>
+
+<p>Por <code>MAX_SAFE_INTEGER</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre deve usar como <code>Number.MAX_SAFE_INTEGER</code>, ao invés de uma propriedade do objeto {{jsxref("Number")}} que você criou.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js notranslate">if (!Number.MAX_SAFE_INTEGER) {
+    Number.MAX_SAFE_INTEGER = 9007199254740991; // Math.pow(2, 53) - 1;
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Retorno_do_valor_de_MAX_SAFE_INTEGER">Retorno do valor de MAX_SAFE_INTEGER</h3>
+
+<pre class="brush: js notranslate">Number.MAX_SAFE_INTEGER; // 9007199254740991
+</pre>
+
+<h3 id="Números_maiores_que_o_inteiro_seguro">Números maiores que o inteiro seguro</h3>
+
+<p>Isso retorna 2 por quê em pontos flutuantes, o valor é na verdade o final decimal "1" exceto em casos subnormais de precisão como zero.</p>
+
+<pre class="brush: js notranslate">Number.MAX_SAFE_INTEGER * Number.EPSILON; // 2
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.max_safe_integer', 'Number.MAX_SAFE_INTEGER')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Number.MAX_SAFE_INTEGER")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.MIN_SAFE_INTEGER")}}</li>
+ <li>{{jsxref("Number.isSafeInteger()")}}</li>
+ <li>{{jsxref("BigInt")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/max_value/index.html b/files/pt-br/web/javascript/reference/global_objects/number/max_value/index.html
new file mode 100644
index 0000000000..2a308f13ed
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/max_value/index.html
@@ -0,0 +1,65 @@
+---
+title: Number.MAX_VALUE
+slug: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
+tags:
+  - JavaScript
+  - Number
+  - Property
+  - Propriedade
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Number.MAX_VALUE</code></strong> representa o maior valor numérico representável em JavaScript.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-maxvalue.html")}}</div>
+
+
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A propriedade <code>MAX_VALUE</code> tem o valor de aproximadamente <code>1.79E+308</code>, ou 2<sup>1024</sup>. Valores maiores que <code>MAX_VALUE</code> são representados como {{jsxref("Infinity")}}.</p>
+
+<p>Por <code>MAX_VALUE</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre deve usar como <code>Number.MAX_VALUE</code>, ao invés de uma propriedade do objeto {{jsxref("Number")}} que você criou. </p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_MAX_VALUE">Usando <code>MAX_VALUE</code></h3>
+
+<p>O código a seguir multiplica dois valores numéricos. Se o resultado é menor ou igual a <code>MAX_VALUE</code>, a função <code>func1</code> é chamada; caso contrário, a função <code>func2</code> é chamada.</p>
+
+<pre class="brush: js notranslate">if (num1 * num2 &lt;= Number.MAX_VALUE) {
+  func1();
+} else {
+  func2();
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.max_value', 'Number.MAX_VALUE')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Number.MAX_VALUE")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.MIN_VALUE")}}</li>
+ <li>O objeto {{jsxref("Number")}} a qual ela pertence</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/min_safe_integer/index.html b/files/pt-br/web/javascript/reference/global_objects/number/min_safe_integer/index.html
new file mode 100644
index 0000000000..ab952dcadb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/min_safe_integer/index.html
@@ -0,0 +1,66 @@
+---
+title: Number.MIN_SAFE_INTEGER
+slug: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Number
+  - Número
+  - Property
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_SAFE_INTEGER
+---
+<div>{{JSRef}}</div>
+
+<p>A constante <strong><code>Number.MIN_SAFE_INTEGER</code></strong> representa o menor inteiro seguro no JavaScript (<code>-(2<sup>53</sup> - 1)</code>).</p>
+
+<p>Para representar inteiros menores do que isso, considere usar {{jsxref("BigInt")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-min-safe-integer.html")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A constante <code>MIN_SAFE_INTEGER</code> tem o valor de <code>-9007199254740991</code> (-9,007,199,254,740,991 ou -9 quadrilhões). A razão por trás deste número é que o JavaScript usa o <a class="external external-icon" href="http://en.wikipedia.org/wiki/Double_precision_floating-point_format" rel="noopener">formato de número de ponto-flutuante de precisão-dupla</a> como especificado na <a class="external external-icon" href="http://en.wikipedia.org/wiki/IEEE_floating_point" rel="noopener">IEEE 754</a> e pode seguramente representar número entre <code>-(2<sup>53</sup> - 1)</code> e <code>2<sup>53</sup> - 1</code>.  Veja {{jsxref("Number.isSafeInteger()")}} para mais informações.</p>
+
+<p>Por <code>MIN_SAFE_INTEGER</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre deve usar como <code>Number.MIN_SAFE_INTEGER</code>, ao invés de uma propriedade do objeto {{jsxref("Number")}} que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_MIN_SAFE_INTEGER">Usando MIN_SAFE_INTEGER</h3>
+
+<pre class="brush: js notranslate">Number.MIN_SAFE_INTEGER // -9007199254740991
+-(Math.pow(2, 53) - 1)  // -9007199254740991
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.min_safe_integer', 'Number.MIN_SAFE_INTEGER')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Number.MIN_SAFE_INTEGER")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.MAX_SAFE_INTEGER")}}</li>
+ <li>{{jsxref("Number.isSafeInteger()")}}</li>
+ <li>{{jsxref("BigInt")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/min_value/index.html b/files/pt-br/web/javascript/reference/global_objects/number/min_value/index.html
new file mode 100644
index 0000000000..6c6738f96f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/min_value/index.html
@@ -0,0 +1,69 @@
+---
+title: Number.MIN_VALUE
+slug: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
+tags:
+  - JavaScript
+  - Number
+  - Número
+  - Property
+  - Propriedade
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Number.MIN_VALUE</code></strong> representa o menor valor positivo numérico representável em JavaScript.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-min-value.html")}}</div>
+
+
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A propriedade <code>MIN_VALUE</code> é o número mais próximo de 0, não o número mais negativo, que o JavaScript pode representar.</p>
+
+<p><code>MIN_VALUE</code> tem o valor de aproximadamente <code>5e-324</code>. Valores menores que <code>MIN_VALUE</code> ("valores de underflow") são convertidos para 0.</p>
+
+<p>Por <code>MIN_VALUE</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre deve usar como <code>Number.MIN_VALUE</code>, ao invés de uma propriedade do objeto {{jsxref("Number")}} que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_MIN_VALUE">Usando <code>MIN_VALUE</code></h3>
+
+<p>O seguinte código divide dois valores numéricos. Se o resultado é maior ou igual a <code>MIN_VALUE</code>, a função <code>func1</code> é chamada; caso contrário, a função <code>func2</code> é chamada.</p>
+
+<pre class="brush: js notranslate">if (num1 / num2 &gt;= Number.MIN_VALUE) {
+  func1();
+} else {
+  func2();
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.min_value', 'Number.MIN_VALUE')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Number.MIN_VALUE")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.MAX_VALUE")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/nan/index.html b/files/pt-br/web/javascript/reference/global_objects/number/nan/index.html
new file mode 100644
index 0000000000..d2c49dee98
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/nan/index.html
@@ -0,0 +1,105 @@
+---
+title: Number.NaN
+slug: Web/JavaScript/Reference/Global_Objects/Number/NaN
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Number.NaN</code></strong> representa Not-A-Number (Não-Número). Equivalente a {{jsxref("NaN")}}.</p>
+
+<p>Você não precisa criar um objeto {{jsxref("Number")}} para acessar esta propriedade estática (use <code>Number.NaN</code>).</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<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">Detalhes</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição Inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.3.4', 'Number.NaN')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.nan', 'Number.NaN')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="sect1"> </h2>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>O objeto global {{jsxref("NaN")}}.</li>
+ <li>O objeto {{jsxref("Number")}} ao qual ele pertence.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/negative_infinity/index.html b/files/pt-br/web/javascript/reference/global_objects/number/negative_infinity/index.html
new file mode 100644
index 0000000000..ca9531f930
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/negative_infinity/index.html
@@ -0,0 +1,84 @@
+---
+title: Number.NEGATIVE_INFINITY
+slug: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY
+tags:
+  - JavaScript
+  - Number
+  - Número
+  - Property
+  - Propriedade
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Number.NEGATIVE_INFINITY</code></strong> representa o valor Infinito negativo.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-negative-infinity.html")}}</div>
+
+
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O valor de <code>Number.NEGATIVE_INFINITY</code> é o mesmo que o valor negativo da propriedade do objeto global {{jsxref("Infinity")}}.</p>
+
+<p>O valor se comporta um pouco diferente do que o infinito matemático:</p>
+
+<ul>
+ <li>Qualquer valor positivo, incluindo {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, mutiplicado por <code>NEGATIVE_INFINITY</code> é <code>NEGATIVE_INFINITY</code>.</li>
+ <li>Qualquer valor negativo, incluindo <code>NEGATIVE_INFINITY</code>, multiplicado por <code>NEGATIVE_INFINITY</code> é {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li>
+ <li>Qualquer valor positivo dividido por <code>NEGATIVE_INFINITY</code> é zero negativo.</li>
+ <li>Qualquer valor negativo dividido por <code>NEGATIVE_INFINITY</code> é zero positivo.</li>
+ <li>Zero multiplicado por <code>NEGATIVE_INFINITY</code> é {{jsxref("NaN")}}.</li>
+ <li>{{jsxref("NaN")}} multiplicado por <code>NEGATIVE_INFINITY</code> é {{jsxref("NaN")}}.</li>
+ <li><code>NEGATIVE_INFINITY</code>, dividido por qualquer valor negativo exceto <code>NEGATIVE_INFINITY</code>, é {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li>
+ <li><code>NEGATIVE_INFINITY</code>, divido por qualquer valor positivo exceto {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, é <code>NEGATIVE_INFINITY</code>.</li>
+ <li><code>NEGATIVE_INFINITY</code>, divido por ou <code>NEGATIVE_INFINITY</code> ou {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, é {{jsxref("NaN")}}.</li>
+</ul>
+
+<p>Você pode usar a propriedade <code>Number.NEGATIVE_INFINITY</code> para indicar uma condição de erro que retorna um número finito em caso de sucesso. Nota que, usar {{jsxref("isFinite")}} seria mais apropriado neste caso.</p>
+
+<p>Por <code>NEGATIVE_INFINITY</code> ser uma propriedade estática de {{jsxref("Number")}}, você sempre a usa como <code>Number.NEGATIVE_INFINITY</code>, ao invés de ser uma propriedade do objeto {{jsxref("Number")}} que você criou.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_NEGATIVE_INFINITY">Usando <code>NEGATIVE_INFINITY</code></h3>
+
+<p>No seguinte exemplo, a variável <code>smallNumber</code> é atribuída um valor que é menor que o valor mínimo. Quando o {{jsxref("Statements/if...else", "if")}} executa, <code>smallNumber</code> tem o valor <code>-Infinity</code>, então é colocado em <code>smallNumber</code> um valor mais manejável antes de continuar.</p>
+
+<pre class="brush: js notranslate">var smallNumber = (-Number.MAX_VALUE) * 2;
+
+if (smallNumber === Number.NEGATIVE_INFINITY) {
+  smallNumber = returnFinite();
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.NEGATIVE_INFINITY")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
+ <li>{{jsxref("Number.isFinite()")}}</li>
+ <li>{{jsxref("Global_Objects/Infinity", "Infinity")}}</li>
+ <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/parsefloat/index.html b/files/pt-br/web/javascript/reference/global_objects/number/parsefloat/index.html
new file mode 100644
index 0000000000..85994f5ca6
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/parsefloat/index.html
@@ -0,0 +1,116 @@
+---
+title: Number.parseFloat()
+slug: Web/JavaScript/Reference/Global_Objects/Number/parseFloat
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseFloat
+---
+<div>{{JSRef("Global_Objects", "Number")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong>Number.parseFloat()</strong> converte a string recebida como argumento e a retorna como um número de ponto flutuante. Este método se comporta de maneira idêntica a da função global {{jsxref("Global_Objects/parseFloat", "parseFloat")}} e é parte da especificação ECMAScript 6 (seu propósito é a modularização dos objetos globais).</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Number.parseFloat(<var>string</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>string</var></code></dt>
+ <dd>Uma string que represente o valor que se deseja converter.<br>
+  </dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<dl>
+ <dt><code><var>string</var></code></dt>
+ <dd>Um número de ponto flutuante a partir da string dada. Se a string não puder ser convertida em para um número, {{jsxref("Global_Objects/NaN","NaN")}} é retornado.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Este método tem a mesma funcionalidade do método global:  {{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</p>
+
+<pre>Number.parseFloat === parseFloat; // true
+</pre>
+
+<p>Por favor veja {{jsxref("parseFloat", "parseFloat()")}} para mais detalhes e exemplos.</p>
+
+<h2 id="Especificação">Especificação</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>
+    <p>{{SpecName('ES6', '#sec-number.parsefloat', 'Number.parseFloat')}}</p>
+   </td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade dos Navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoDesktop("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("25")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>O objeto {{jsxref("Global_Objects/Number", "Number")}} ao qual o método parseFloat pertence.</li>
+ <li>O método global {{jsxref("Global_Objects/parseFloat", "parseFloat()")}}.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/parseint/index.html b/files/pt-br/web/javascript/reference/global_objects/number/parseint/index.html
new file mode 100644
index 0000000000..88c3c6735b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/parseint/index.html
@@ -0,0 +1,85 @@
+---
+title: Number.parseInt()
+slug: Web/JavaScript/Reference/Global_Objects/Number/parseInt
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Method
+  - Number
+  - Número
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/parseInt
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Number.parseInt()</code></strong> converte um argumento de <em>string</em> e retorna um inteiro da raiz ou base específica.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-parseint.html", "taller")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">Number.parseInt(<var>string,</var>[ <var>radix</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<div>
+<dl>
+ <dt><code><var>string</var></code></dt>
+ <dd>O valor a ser convertido. Se este argumento não for uma <em>string</em>, então ele é convertido a um usando a operação abstrata <code><a href="https://tc39.es/ecma262/#sec-tostring">ToString</a></code>. O espaço em branco inicial neste argumento é ignorado.</dd>
+ <dt><code><var>radix</var></code><var> {{optional_inline}}</var></dt>
+ <dd>Um inteiro entre <code>2</code> e <code>36</code> que representa a <em>raiz</em>  (a base no sistema numérico matemático) de uma <code><var>string</var></code>. Tome cuidado—o padrão <em><strong>não</strong></em> é <code>10</code>!</dd>
+</dl>
+</div>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um inteiro convertido de uma dada <code><var>string</var></code>.</p>
+
+<p>Se a <code><var>radix</var></code> é menor que <code>2</code> ou maior que <code>36</code>, e o primeiro caracter que não é um espaço em branco não puder ser convertido para um número, {{jsxref("NaN")}} é retornado.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js notranslate">if (Number.parseInt === undefined) {
+    Number.parseInt = window.parseInt
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Number.parseInt_vs_parseInt">Number.parseInt vs parseInt</h3>
+
+<p>Este método tem a mesma funcionalidade que o método global {{jsxref("parseInt", "parseInt()")}}:</p>
+
+<pre class="brush: js notranslate">Number.parseInt === parseInt // true</pre>
+
+<p>e é parte do ECMAScript 2015 (sua proposta é a modularização dos globais). Por favor veja {{jsxref("parseInt", "parseInt()")}} para mais detalhes e exemplos.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.parseint', 'Number.parseInt')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Number.parseInt")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>O objeto {{jsxref("Number")}} a qual ela pertence.</li>
+ <li>O método global {{jsxref("parseInt", "parseInt()")}}.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/positive_infinity/index.html b/files/pt-br/web/javascript/reference/global_objects/number/positive_infinity/index.html
new file mode 100644
index 0000000000..b6ac31f1ec
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/positive_infinity/index.html
@@ -0,0 +1,92 @@
+---
+title: Number.POSITIVE_INFINITY
+slug: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/POSITIVE_INFINITY
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Number.POSITIVE_INFINITY</code></strong> representa o valor positivo infinito.</p>
+
+<p>Você não precisa criar um objeto {{jsxref("Number")}} para utilizar a propriedade estática (use <code>Number.POSITIVE_INFINITY</code>).</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O valor de <code>Number.POSITIVE_INFINITY</code> é o mesmo valor da propriedade {{jsxref("Infinity")}} do objeto global.</p>
+
+<p>Esse valor se comporta ligeiramente diferente do infinito matemático:</p>
+
+<ul>
+ <li>Qualquer valor positivo, incluindo <code>POSITIVE_INFINITY</code>, multiplicado por <code>POSITIVE_INFINITY</code> é <code>POSITIVE_INFINITY</code>.</li>
+ <li>Qualquer valor negativo, incluindo, {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, multiplicado por <code>POSITIVE_INFINITY</code> é {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li>
+ <li>Qualquer número positivo dividido por <code>POSITIVE_INFINITY</code> é Zero positivo.</li>
+ <li>Qualquer número negativo dividido por <code>POSITIVE_INFINITY</code> é Zero negativo.</li>
+ <li>Zero multiplicado por <code>POSITIVE_INFINITY</code> é {{jsxref("NaN")}}.</li>
+ <li>{{jsxref("Global_Objects/NaN", "NaN")}} multiplicado por <code>POSITIVE_INFINITY</code> é {{jsxref("NaN")}}.</li>
+ <li><code>POSITIVE_INFINITY</code>, dividido por qualquer valor negativo exceto {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}, é {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}}.</li>
+ <li><code>POSITIVE_INFINITY</code>, dividido por qualquer valor positivo exceto <code>POSITIVE_INFINITY</code>, é <code>POSITIVE_INFINITY</code>.</li>
+ <li><code>POSITIVE_INFINITY</code>, dividido por {{jsxref("Number.NEGATIVE_INFINITY", "NEGATIVE_INFINITY")}} ou <code>POSITIVE_INFINITY</code>, é {{jsxref("NaN")}}.</li>
+</ul>
+
+<p>Você pode usar a propriedade <code>Number.POSITIVE_INFINITY</code> para indicar uma condição de erro que retorna um número finito no caso de sucesso. Sobretudo, {{jsxref("isFinite")}} seria mais apropriado nesse caso.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_POSITIVE_INFINITY">Usando <code>POSITIVE_INFINITY</code></h3>
+
+<p>No exemplo a seguir, a variável <code>bigNumber</code> recebe um valor maior que o valor máximo. Quando as declarações {{jsxref("Statements/if...else", "if")}} executam, <code>bigNumber</code> tem o valor <code>Infinity</code>, então <code>bigNumber</code> recebe um valor mais gerenciável antes de continuar.</p>
+
+<pre class="brush: js">var bigNumber = Number.MAX_VALUE * 2;
+
+if (bigNumber == Number.POSITIVE_INFINITY) {
+  bigNumber = returnFinite();
+}
+</pre>
+
+<h2 id="Especificação">Especificação</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.3.6', 'Number.POSITIVE_INFINITY')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.positive_infinity', 'Number.POSITIVE_INFINITY')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.POSITIVE_INFINITY")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
+ <li>{{jsxref("Number.isFinite()")}}</li>
+ <li>{{jsxref("Infinity")}}</li>
+ <li>{{jsxref("isFinite", "isFinite()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/number/prototype/index.html
new file mode 100644
index 0000000000..01b988c542
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/prototype/index.html
@@ -0,0 +1,139 @@
+---
+title: Number.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Number/prototype
+tags:
+  - JavaScript
+  - Número
+  - Propriedade
+  - Prototipo
+translation_of: Web/JavaScript/Reference/Global_Objects/Number
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>Number.prototype</code></strong> representa o protótipo para o construtor {{jsxref("Number")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Todas instâncias {{jsxref("Number")}} herdam de <code>Number.prototype</code>. O objeto 'prototype' do construtor {{jsxref("Number")}} pode ser modificado para afetar todas instâncias {{jsxref( "Number")}}.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>Number.prototype.constructor</code></dt>
+ <dd>Retorna a função que criou esta instância do objeto. Por padrão, este é o objeto {{jsxref("Number")}}.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Number.prototype.toExponential()")}}</dt>
+ <dd>Retorna uma 'string' representando o número em notação exponencial.</dd>
+ <dt>{{jsxref("Number.prototype.toFixed()")}}</dt>
+ <dd>Retorna uma 'string' representando o número em notação em ponto fixo.</dd>
+ <dt>{{jsxref("Number.prototype.toLocaleString()")}}</dt>
+ <dd>Retorna uma 'string'  com uma representação sensível ao idioma deste número.  Substitui o método {{jsxref("Object.prototype.toLocaleString()")}}.</dd>
+ <dt>{{jsxref("Number.prototype.toPrecision()")}}</dt>
+ <dd>Retorna uma 'string' representando o número para uma precisão específica em notação ponto fixo ou exponencial.</dd>
+ <dt>{{jsxref("Number.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna uma objeto literal representando um objeto específicado {{jsxref("Number")}}; você pode usar este valor para criar um novo objeto. Substitui o método {{jsxref("Object.prototype.toSource()")}}.</dd>
+ <dt>{{jsxref("Number.prototype.toString()")}}</dt>
+ <dd>Retorna uma 'string' representando o objeto especificado na raiz especificada (base). Substitui o método {{jsxref("Object.prototype.toString()")}}.</dd>
+ <dt>{{jsxref("Number.prototype.valueOf()")}}</dt>
+ <dd>Retorna o valor primitivo do objeto especificado. Substitui o método {{jsxref("Object.prototype.valueOf()")}}.</dd>
+</dl>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.4', 'Number')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-properties-of-the-number-prototype-object', 'Number')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/toexponential/index.html b/files/pt-br/web/javascript/reference/global_objects/number/toexponential/index.html
new file mode 100644
index 0000000000..743a4b32b0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/toexponential/index.html
@@ -0,0 +1,149 @@
+---
+title: Number.prototype.toExponential()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toExponential
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toExponential
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toExponential()</code></strong> retorna uma string  representando o objeto {{jsxref("Global_Objects/Number", "Number")}} por meio de notação exponencial.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><code><var>numObj</var>.toExponential([<var>fractionDigits</var>])</code></pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>fractionDigits</code></dt>
+ <dd>Optional. An integer specifying the number of digits after the decimal point. Defaults to as many digits as necessary to specify the number.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>A string representing the given {{jsxref("Number")}} object in exponential notation with one digit before the decimal point, rounded to <code>fractionDigits</code> digits after the decimal point.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<dl>
+ <dt>{{jsxref("RangeError")}}</dt>
+ <dd>If <code>fractionDigits</code> is too small or too large. Values between 0 and 20, inclusive, will not cause a {{jsxref("RangeError")}}. Implementations are allowed to support larger and smaller values as well.</dd>
+ <dt>{{jsxref("TypeError")}}</dt>
+ <dd>If this method is invoked on an object that is not a {{jsxref("Number")}}.</dd>
+</dl>
+
+<h2 id="Description">Description</h2>
+
+<p>If the <code>fractionDigits</code> argument is omitted, the number of digits after the decimal point defaults to the number of digits necessary to represent the value uniquely.</p>
+
+<p>If you use the <code>toExponential()</code> method for a numeric literal and the numeric literal has no exponent and no decimal point, leave whitespace(s) before the dot that precedes the method call to prevent the dot from being interpreted as a decimal point.</p>
+
+<p>If a number has more digits than requested by the <code>fractionDigits</code> parameter, the number is rounded to the nearest number represented by <code>fractionDigits</code> digits. See the discussion of rounding in the description of the {{jsxref("Number.prototype.toFixed", "toFixed()")}} method, which also applies to <code>toExponential()</code>.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_toExponential">Using <code>toExponential</code></h3>
+
+<pre class="brush: js">var numObj = 77.1234;
+
+console.log(numObj.toExponential());  // logs 7.71234e+1
+console.log(numObj.toExponential(4)); // logs 7.7123e+1
+console.log(numObj.toExponential(2)); // logs 7.71e+1
+console.log(77.1234.toExponential()); // logs 7.71234e+1
+console.log(77 .toExponential());     // logs 7.7e+1
+</pre>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.4.6', 'Number.prototype.toExponential')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.prototype.toexponential', 'Number.prototype.toExponential')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toFixed()")}}</li>
+ <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
+ <li>{{jsxref("Number.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/tofixed/index.html b/files/pt-br/web/javascript/reference/global_objects/number/tofixed/index.html
new file mode 100644
index 0000000000..1b64e75c82
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/tofixed/index.html
@@ -0,0 +1,99 @@
+---
+title: Number.prototype.toFixed()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toFixed
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toFixed
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toFixed()</code></strong> formata um número utilizando notação de ponto fixo.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>numObj</var>.toFixed([<var>dígitos</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>dígitos</code></dt>
+ <dd>Opcional. O número de dígitos que aparecem depois do ponto decimal; este pode ser um valor entre 0 e 20, inclusive, e algumas implementacões podem suportar uma variação de números maiores. Se este argumento for omitido, será tratado como 0. </dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Uma string representando o número usando notação em ponto fixo.</p>
+
+<h3 id="Throws">Throws</h3>
+
+<dl>
+ <dt>{{jsxref("RangeError")}}</dt>
+ <dd>Se <code>dígitos</code> for muito pequeno ou muito grande. Valores entre 0 e 20, inclusive, não irão causar o {{jsxref("RangeError")}}. É permitido às implementações suportar valores maiores e menores.</dd>
+ <dt>{{jsxref("TypeError")}}</dt>
+ <dd>Se este método for chamado em um objeto que não é {{jsxref( "Number")}}.</dd>
+</dl>
+
+
+<h2 id="Descrição">Descrição</h2>
+<p>Uma string representando <code>numObj</code> que não usa notação exponencial e tem exatamente <code>dígitos</code> dígitos depois da casa decimal. O número será arredondado se necessário, e será adicionado zeros a parte após a virgula para que este tenha o tamanho que foi especificado. Se o <code>numObj</code> for maior que <code>1e+21</code>, entao será invocado o método {{jsxref("Number.prototype.toString()")}} e será retornado uma string em notação exponencial.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_toFixed">Utilizando <code>toFixed</code></h3>
+
+<pre class="brush: js">var numObj = 12345.6789;
+
+numObj.toFixed();       // Retorna '12346': note o arredondamento, não possui nenhuma parte fracionária
+numObj.toFixed(1);      // Retorna '12345.7': note o arredondamento
+numObj.toFixed(6);      // Retorna '12345.678900': note que adicionou zeros
+(1.23e+20).toFixed(2);  // Retorna '123000000000000000000.00'
+(1.23e-10).toFixed(2);  // Retorna '0.00'
+2.34.toFixed(1);        // Retorna '2.3'
+2.35.toFixed(1);        // Retorna '2.4'. Note que arredonda para cima neste caso.
+-2.34.toFixed(1);       // Retorna -2.3 (devido à precedência do operador, literais de números negativos não retornam uma string...)
+(-2.34).toFixed(1);     // Retorna '-2.3' (...a menos que se utilize parênteses)
+</pre>
+
+<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>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição incial. Implementada no JavaScript 1.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.4.5', 'Number.prototype.toFixed')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.prototype.tofixed', 'Number.prototype.toFixed')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+{{Compat("javascript.builtins.Number.toFixed")}}
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toExponential()")}}</li>
+ <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
+ <li>{{jsxref("Number.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/tolocalestring/index.html b/files/pt-br/web/javascript/reference/global_objects/number/tolocalestring/index.html
new file mode 100644
index 0000000000..d4ced2ffff
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/tolocalestring/index.html
@@ -0,0 +1,176 @@
+---
+title: Number.prototype.toLocaleString()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
+tags:
+  - Internacionalização
+  - JavaScript
+  - Método(2)
+  - Number
+  - Número
+  - Prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toLocaleString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toLocaleString()</code></strong> retorna uma string com uma representação sensível a linguagem deste número.</p>
+
+<p>Os novos argumentos <code>locales</code> e <code>options</code> permitem às aplicações especificar a linguagem cujas convenções de formatações serão utilizadas e personalizar o comportamento da função. Nas implementações anteriores, que ignorava os argumentos <code>locales</code> e <code>options</code> arguments, a localização utilizada e a forma de retornar a string erão totalmente dependente da implementação.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>numObj</em>.toLocaleString(</code><code>[locales [, options]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p>Dê uma olhada na seção <a href="#Browser_compatibility">Compatibilidade do Navegador</a> para verificar quais navegadores suportam os argumentos <code>locales</code> e <code>options</code>, e o <a href="#">Exemplo: Verificando o suporte dos argumentos <code>locales</code> e <code>options</code></a> para detecção desta característica.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> ECMAScript Internationalization API, implementada com o Firefox 29, incluiu o argumento <code>locales</code> ao método <code>Number.toLocaleString()</code>. Se o argumento for {{jsxref("undefined")}}, este método retorna os dígitos de localização especificados pelo SO, enquanto que as versões anteriores doFirefox retornavam os dígitos<a href="https://en.wikipedia.org/wiki/Arabic_numerals"> Árabe Ocidental</a>. Esta mudança foi relatada como uma regressão que afeta a retrocompatibilidade que será corrigida em breve. ({{bug(999003)}})</p>
+</div>
+
+<div>{{page('pt-BR/docs/Web/JavaScript/Reference/Global_Objects/NumberFormat', 'Parâmetros')}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toLocaleString">Usando <code>toLocaleString</code></h3>
+
+<p>No uso básico sem a especificação de uma localização, o método retornará uma string formatada com a localização e as opções padrão.</p>
+
+<pre class="brush: js">var numero = 3500;
+
+console.log(numero.toLocaleString()); // Mostra "3,500" se a localização for U.S. English
+</pre>
+
+<h3 id="Verificando_o_suporte_dos_argumentos_locales_e_options">Verificando o suporte dos argumentos <code>locales</code> e <code>options</code></h3>
+
+<p>Os argumentos <code>locales</code> e <code>options</code> não são suportados por todos os navegadores ainda. Para verificar pelo suporte das implementações do ES5.1 e posteriores, a requisição de tags de linguagem ilegais são rejeitadas com uma exceção {{jsxref("Global_Objects/RangeError", "RangeError")}} pode ser usada da seguinte forma:</p>
+
+<pre class="brush: js">function toLocaleStringSupportsLocales() {
+  var numero = 0;
+  try {
+     numero.toLocaleString('i');
+  } catch (e) {
+    return e.name === 'RangeError';
+  }
+  return false;
+}
+</pre>
+
+<p>Antes da ES5.1, implementações que não exigiam um tratamento de erro se <code>toLocaleString</code> fosse chamada com argumentos.</p>
+
+<p>Uma verificação que funciona em todos os casos, incluindo aqueles que suportam ECMA-262 antes da edição 5.1, é testar pelas especificações de característicadas da ECMA-402 que exigem suporte de opções regionais para <code>Number.prototype.toLocaleString</code> diretamente:</p>
+
+<pre class="brush: js">function toLocaleStringSupportsOptions() {
+  return !!(typeof Intl == 'object' &amp;&amp; Intl &amp;&amp; typeof Intl.NumberFormat == 'function');
+}
+</pre>
+
+<p>Estes testes para um objeto <code>Intl</code> global, verifica se ele não é <code>null</code> e se uma propriedade <code>NumberFormat</code> é uma função.</p>
+
+<h3 id="Usando_locales">Usando <code>locales</code></h3>
+
+<p>Este exemplo mostra algumas variações de formatos de números localizados. A fim de obter o formato da linguagem utilizada na interface do usuário da sua aplicação, tenha certeza de especificar a língua (e possivelmente algumas línguas reservas) usando o argumento<code> locales</code>:</p>
+
+<pre class="brush: js">var numero = 123456.789;
+
+// O alemão usa vírgula como separador de decimal e ponto para milhares
+console.log(numero.toLocaleString('de-DE'));
+// → 123.456,789
+
+// O árabe usa dígitos <a href="https://en.wikipedia.org/wiki/Eastern_Arabic_numerals">Árabes Orientais</a> em muitos países que falam árabe
+console.log(numero.toLocaleString('ar-EG'));
+// → ١٢٣٤٥٦٫٧٨٩
+
+// A Índia usa separadores de milhares/cem mil/dez milhões
+console.log(numero.toLocaleString('en-IN'));
+// → 1,23,456.789
+
+// A chave de extensão nu requer um sistema de numeração, ex. decimal chinês
+console.log(numero.toLocaleString('zh-Hans-CN-u-nu-hanidec'));
+// → 一二三,四五六.七八九
+
+// Quando informada uma língua sem suporte, como balinês,
+// inclua uma língua reseva, neste caso indonésio
+console.log(numero.toLocaleString(['ban', 'id']));
+// → 123.456,789
+</pre>
+
+<h3 id="Usando_options">Usando <code>options</code></h3>
+
+<p>Os resultados obtidos por <code>toLocaleString</code> pode ser personalizado usando o argumento<code> options</code>:</p>
+
+<pre class="brush: js">var numero = 123456.789;
+
+// informando um formato de moeda
+console.log(numero.toLocaleString('de-DE', { style: 'currency', currency: 'EUR' }));
+// → 123.456,79 €
+
+// o yen japonês não tem uma unidade menor
+console.log(numero.toLocaleString('ja-JP', { style: 'currency', currency: 'JPY' }))
+// → ￥123,457
+
+// limitando a três dígitos significativos
+console.log(numero.toLocaleString('en-IN', { maximumSignificantDigits: 3 }));
+// → 1,23,000
+</pre>
+
+<h2 id="Desempenho">Desempenho</h2>
+
+<p>Quando formatar uma grande quantidade de números, é melhor criar um objeto {{jsxref("NumberFormat")}} e usar a função fornecida pela propriedade {{jsxref("NumberFormat.format")}}.</p>
+
+<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('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.4.3', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.prototype.tolocalestring', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 1.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES Int 1.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int 2.0', '#sec-13.2.1', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES Int 2.0')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sec-Number.prototype.toLocaleString', 'Number.prototype.toLocaleString')}}</td>
+   <td>{{Spec2('ES Int Draft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<p>{{Compat("javascript.builtins.Number.toLocaleString")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/toprecision/index.html b/files/pt-br/web/javascript/reference/global_objects/number/toprecision/index.html
new file mode 100644
index 0000000000..643a0b9a08
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/toprecision/index.html
@@ -0,0 +1,104 @@
+---
+title: Number.prototype.toPrecision()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toPrecision
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toPrecision
+---
+<div>{{JSRef}}</div>
+
+<div></div>
+
+<p>O método <strong><code>toPrecision()</code></strong> retorna uma string que representa o valor do objeto {{jsxref("Number")}} com uma precisão específica.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-toprecision.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>numObj</var>.toPrecision([<var>precisão</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>precisão</code></dt>
+ <dd>Opcional. Um inteiro especificando o número de algarismos significativos.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Uma string representando um objeto {{jsxref("Number")}} em notação de ponto fixo ou exponencial arredondada segundo o parâmetro <code>precisão</code>. Veja a discussão sobre arredondamento feita na documentação do método {{jsxref("Number.prototype.toFixed()")}}, que também se aplica ao método <code>toPrecision()</code>.</p>
+
+<p>Se o parâmetro <code>precisão</code> for omitido, este método terá o mesmo comportamento de {{jsxref("Number.prototype.toString()")}}. Se o parâmetro <code>precisão</code> for um valor não inteiro, ele será arredondado para a sua representação mais próxima em inteiro.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<dl>
+ <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt>
+ <dd>Se o valor de <code>precisão</code> não estiver compreendido entre 1 e 100 (inclusive), um  {{jsxref("RangeError")}} será lançado. É permitido às implementações suportar valores menores e maiores que esses, sendo um requisito do ECMA-262 que seja dado suporte a uma precisão de até 21 algarismos significativos.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_toPrecision">Utilizando <code>toPrecision</code></h3>
+
+<pre class="brush: js">var numObj = 5.123456;
+
+console.log(numObj.toPrecision());    // logs '5.123456'
+console.log(numObj.toPrecision(5));   // logs '5.1235'
+console.log(numObj.toPrecision(2));   // logs '5.1'
+console.log(numObj.toPrecision(1));   // logs '5'
+
+numObj = 0.000123
+
+console.log(numObj.toPrecision());    // logs '0.000123'
+console.log(numObj.toPrecision(5));   // logs '0.00012300'
+console.log(numObj.toPrecision(2));   // logs '0.00012'
+console.log(numObj.toPrecision(1));   // logs '0.0001'
+
+// observe que a notação exponencial pode ser retornado em alguns casos
+console.log((1234.5).toPrecision(2)); // logs '1.2e+3'
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.4.7', 'Number.prototype.toPrecision')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.prototype.toprecision', 'Number.prototype.toPrecision')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<p class="hidden">A tabela de compatibilidade nesta página foi gerada a partir de dados estruturados. Se você quiser contribuir para a base de dados, por favor, dê uma olhada em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos sua requisição.</p>
+
+<p>{{Compat("javascript.builtins.Number.toPrecision")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toFixed()")}}</li>
+ <li>{{jsxref("Number.prototype.toExponential()")}}</li>
+ <li>{{jsxref("Number.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/number/tosource/index.html
new file mode 100644
index 0000000000..8d10118b0a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/tosource/index.html
@@ -0,0 +1,48 @@
+---
+title: Number.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toSource
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toSource
+---
+<div>{{JSRef}} {{non-standard_header}}</div>
+
+<p>O método <strong><code>toSource()</code></strong> retorna uma string contendo o código fonte do objeto.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>numObj</var>.toSource()
+Number.toSource()</pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo o código fonte do objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>toSource()</code> retorna os seguintes valores:</p>
+
+<p>Para o objeto built-in {{jsxref("Number")}}, o método <code>toSource()</code> retorna a seguinte string indicando que o código fonte do objeto não está disponível:</p>
+
+<pre class="brush: js">function Number() {
+    [native code]
+}
+</pre>
+
+<p>Para instâncias do objeto {{jsxref("Number")}}, <code>toSource()</code> retorna uma string contendo o código fonte.</p>
+
+<p>Este método normalmente é invocado internamente pelo JavaScript e não explicitamente em um código web.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não é parte de nenhuma especificação padrão. Implementado no JavaScript 1.3.</p>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.toSource")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/number/tostring/index.html
new file mode 100644
index 0000000000..6ebd43e978
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/tostring/index.html
@@ -0,0 +1,143 @@
+---
+title: Number.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Number/toString
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString
+---
+<div>{{JSRef("Global_Objects", "Number")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong><code>toString()</code></strong> retorna uma string representando o objeto {{jsxref("Global_Objects/Number", "Number")}} especificado.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>numObj</var>.toString([<var>radix</var>])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>radix</code></dt>
+ <dd>Opcional. Um inteiro entre 2 e 36 especificando a base utilizada para representar os valores numéricos.</dd>
+</dl>
+
+<h3 id="Throws" name="Throws">Exceções</h3>
+
+<dl>
+ <dt>{{jsxref("Global_Objects/RangeError", "RangeError")}}</dt>
+ <dd>se <code>toString()</code> receber um valor de radix fora do intervalo entre 2 e 36, uma exceção {{jsxref("Global_Objects/RangeError", "RangeError")}} é lançada.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O objeto {{jsxref("Global_Objects/Number", "Number")}} sobrescreve o método <code>toString()</code> do objeto {{jsxref("Global_Objects/Object", "Object")}}; ele não herda  de {{jsxref("Object.prototype.toString()")}}. Para objetos {{jsxref("Global_Objects/Number", "Number")}}, o método <code>toString()</code> retorna uma representação string do objeto na base especificada.</p>
+
+<p>O método <code>toString()</code> analisa seu primeiro argumento e tenta retornar uma representação string na raiz (base) especificada. Para raizes maiores que 10, as letras do alfabeto indicam valores maiores que 9. Por exemplo, para números hexadecimais (base 16),  letras entre <code>a</code> e <code>f</code> são utilizadas.</p>
+
+<p>Se o <code>radix</code> não for especificado, a raiz assumida como preferencial é a 10.</p>
+
+<p>Se o <code>numObj</code> for negativo, o sinal é preservado. Isto acontece mesmo se a raiz for 2; a string retornada é a representação binária positiva de <code>numObj</code> precedida por um sinal <code>- e</code> <strong>não</strong> o complemento de dois do <code>numObj</code>.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_toString" name="Example:_Using_toString">Exemplo: Usando <code>toString</code></h3>
+
+<pre class="brush: js">var count = 10;
+
+console.log(count.toString());    // displays '10'
+console.log((17).toString());     // displays '17'
+
+var x = 6;
+
+console.log(x.toString(2));       // displays '110'
+console.log((254).toString(16));  // displays 'fe'
+
+console.log((-10).toString(2));   // displays '-1010'
+console.log((-0xff).toString(2)); // displays '-11111111'
+</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ários</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1ª edição.</td>
+   <td>Standard</td>
+   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.4.2', 'Number.prototype.tostring')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toFixed()")}}</li>
+ <li>{{jsxref("Number.prototype.toExponential()")}}</li>
+ <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/number/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/number/valueof/index.html
new file mode 100644
index 0000000000..7406994df7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/number/valueof/index.html
@@ -0,0 +1,80 @@
+---
+title: Number.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/Number/valueOf
+translation_of: Web/JavaScript/Reference/Global_Objects/Number/valueOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>valueOf()</code></strong> retorna o valor primitivo contido no objeto {{jsxref("Number")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/number-valueof.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>numObj</var>.valueOf()</pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um número representando o valor primitivo do objeto {{jsxref("Number")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Este método normalmente é invocado internamente pelo JavaScript e não explicitamente em um código web.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_valueOf">Utilizando <code>valueOf</code></h3>
+
+<pre class="brush: js">var numObj = new Number(10);
+console.log(typeof numObj); // object
+
+var num = numObj.valueOf();
+console.log(num);           // 10
+console.log(typeof num);    // number
+</pre>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.7.4.4', 'Number.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-number.prototype.valueof', 'Number.prototype.valueOf')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Number.valueOf")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Number.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/__definegetter__/index.html b/files/pt-br/web/javascript/reference/global_objects/object/__definegetter__/index.html
new file mode 100644
index 0000000000..4c942f9ba7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/__definegetter__/index.html
@@ -0,0 +1,102 @@
+---
+title: Object.prototype.__defineGetter__()
+slug: Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__
+tags:
+  - Depreciado
+  - JavaScript
+  - Objeto
+  - Prototipo
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/__defineGetter__
+---
+<div>{{JSRef}}</div>
+
+<div class="warning">
+<p>Esta característica está descontinuada em favor de definindo getters usando a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">sintaxe de inicialização de objeto </a>ou a API {{jsxref("Object.defineProperty()")}}. Enquanto esta característica é amplamente implementada, ela está somente descrita na <a href="https://tc39.github.io/ecma262/#sec-additional-ecmascript-features-for-web-browsers">especificação ECMAScript </a> por causa do uso legado. Este método não deveria ser usado desde que exista existam melhores alternativas.</p>
+</div>
+
+<p>O método <code><strong>__defineGetter__</strong></code> conecta uma propriedade do objeto à uma função para ser chamada quando isso é consultado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>obj</var>.__defineGetter__(<var>prop</var>, <var>func</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Uma string contendo o nome da propriedade para conectar a função dada.</dd>
+ <dt><code>func</code></dt>
+ <dd>Uma função para ser ligada a uma consulta da propriedade especificada.</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>{{jsxref("undefined")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>__defineGetter__</code> permite um {{jsxref("Operators/get", "getter", "", 1)}} ser definido sobre um objeto preexistente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">// Forma não-padrão e depreciada
+
+var o = {};
+o.__defineGetter__('gimmeFive', function() { return 5; });
+console.log(o.gimmeFive); // 5
+
+
+// Formas padrão-compatível
+
+// Usando o operador get
+var o = { get gimmeFive() { return 5; } };
+console.log(o.gimmeFive); // 5
+
+// Usando Object.defineProperty
+var o = {};
+Object.defineProperty(o, 'gimmeFive', {
+  get: function() {
+    return 5;
+  }
+});
+console.log(o.gimmeFive); // 5
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="spectable 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('ESDraft', '#sec-object.prototype.__defineGetter__', 'Object.prototype.__defineGetter__()')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Incluido no (normativa) anexo para adicionais características legadas ECMAScript para navegadores Web (note que a especificação codifica o que já está em implementações).</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navagadores">Compatibilidade de navagadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.defineGetter")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.__defineSetter__()")}}</li>
+ <li>{{jsxref("Operators/get", "get")}} operator</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.prototype.__lookupGetter__()")}}</li>
+ <li>{{jsxref("Object.prototype.__lookupSetter__()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">Guia JS: Definindo Getters e Setters</a></li>
+ <li><a href="https://whereswalden.com/2010/04/16/more-spidermonkey-changes-ancient-esoteric-very-rarely-used-syntax-for-creating-getters-and-setters-is-being-removed/">[Blog Post] Depreciação de __defineGetter__ e __defineSetter__</a></li>
+ <li>{{bug(647423)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/__definesetter__/index.html b/files/pt-br/web/javascript/reference/global_objects/object/__definesetter__/index.html
new file mode 100644
index 0000000000..0f82f96400
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/__definesetter__/index.html
@@ -0,0 +1,117 @@
+---
+title: Object.prototype.__defineSetter__()
+slug: Web/JavaScript/Reference/Global_Objects/Object/__defineSetter__
+tags:
+  - Deprecated
+  - Depreciado
+  - JavaScript
+  - Method
+  - Object
+  - Objeto
+  - Prototipo
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/__defineSetter__
+---
+<div>{{JSRef}}</div>
+
+<div class="warning">
+<p>Esta funcionalidade está depreciada em favor da definição de setters usando a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">sintaxe de inicialização de objeto</a> ou a API {{jsxref("Object.defineProperty()")}}.</p>
+
+<p>Entretando, como ele é largamente implementado e usado na Web, é bem improvável que os navegadores vão parar de implementá-lo.</p>
+</div>
+
+<p>O método <code><strong>__defineSetter__</strong></code> vincula uma propriedade de um objeto a uma função a ser chamada quando é feita uma tentativa de atribuir algo a aquela propriedade.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>obj</var>.__defineSetter__(<var>prop</var>, <var>fun</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Uma cadeia de caracteres (<em>string</em>) contendo o nome da propriedade que vai ser vinculada a função dada.</dd>
+ <dt><code>fun</code></dt>
+ <dd>A função a ser chamada quando houver uma tentativa de atribuir na propriedade especificada. Esta função toma a forma
+ <pre class="brush: js notranslate">function(<var>val</var>) { . . . }</pre>
+
+ <dl>
+  <dt><code>val</code></dt>
+  <dd>Um apelido para a variável que contém o valor que se tentou atribuir a <code>prop</code>.</dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>{{jsxref("undefined")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>__defineSetter__</code> permite um {{jsxref("Operators/set", "setter", "", 1)}} ser definido a um objeto pré-existente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Não_padronizados_e_forma_depreciada">Não padronizados e forma depreciada</h3>
+
+<pre class="brush: js notranslate">var o = {};
+o.__defineSetter__('value', function(val) { this.anotherValue = val; });
+o.value = 5;
+console.log(o.value); // undefined
+console.log(o.anotherValue); // 5
+</pre>
+
+<h3 id="Formas_compatíveis_padronizadas">Formas compatíveis padronizadas</h3>
+
+<pre class="brush: js notranslate">// Usando o operador set
+var o = { set value(val) { this.anotherValue = val; } };
+o.value = 5;
+console.log(o.value); // undefined
+console.log(o.anotherValue); // 5
+
+// Usando Object.defineProperty
+var o = {};
+Object.defineProperty(o, 'value', {
+  set: function(val) {
+    this.anotherValue = val;
+  }
+});
+o.value = 5;
+console.log(o.value); // undefined
+console.log(o.anotherValue); // 5
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="spectable standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.__defineSetter__', 'Object.prototype.__defineSetter__()')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.defineSetter")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.__defineGetter__()")}}</li>
+ <li>Operador {{jsxref("Operators/set", "set")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.prototype.__lookupGetter__()")}}</li>
+ <li>{{jsxref("Object.prototype.__lookupSetter__()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">JS Guide: Defining Getters and Setters</a></li>
+ <li><a href="http://whereswalden.com/2010/04/16/more-spidermonkey-changes-ancient-esoteric-very-rarely-used-syntax-for-creating-getters-and-setters-is-being-removed/">[Blog Post] Deprecation of __defineGetter__ and __defineSetter__</a></li>
+ <li><a href="https://bugzilla.mozilla.org/show_bug.cgi?id=647423">bug 647423</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/__lookupgetter__/index.html b/files/pt-br/web/javascript/reference/global_objects/object/__lookupgetter__/index.html
new file mode 100644
index 0000000000..c9f2d29fcd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/__lookupgetter__/index.html
@@ -0,0 +1,84 @@
+---
+title: Object.prototype.__lookupGetter__()
+slug: Web/JavaScript/Reference/Global_Objects/Object/__lookupGetter__
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/__lookupGetter__
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code><strong>__lookupGetter__</strong></code> retorna a função limite como uma getter para a específica propriedade.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>obj</var>.__lookupGetter__(<var>sprop</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>sprop</code></dt>
+ <dd>Uma sequência de caracteres contendo o nome da propriedade cuja getter deve retornar.</dd>
+</dl>
+
+<h3 id="Valores_de_retorno">Valores de retorno</h3>
+
+<p>A função limite como uma getter para a específica propriedade.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se uma getter foi definida por uma propriedade de um objeto, não é possível referir-se a função getter através da propriedade, porque essa propriedade se refere ao retorno do valor daquela função. <code>__lookupGetter__</code> pode ser usado para obter referência à função getter.</p>
+
+<p>Agora é possível fazer isso de um jeito uniforme usando:. {{jsxref("Object.getOwnPropertyDescriptor()")}} e  {{jsxref("Object.getPrototypeOf()")}}.</p>
+
+<h2 id="Examplos">Examplos</h2>
+
+<pre class="brush: js">var obj = {
+  get foo() {
+    return Math.random() &gt; 0.5 ? 'foo' : 'bar';
+  }
+};
+
+
+// Non-standard and deprecated way
+obj.__lookupGetter__('foo');
+// (function() { return Math.random() &gt; 0.5 ? 'foo' : 'bar'; })
+
+
+// Standard-compliant way
+Object.getOwnPropertyDescriptor(obj, "foo").get;
+// (function() { return Math.random() &gt; 0.5 ? 'foo' : 'bar'; })
+</pre>
+
+<h2 id="Specificações">Specificações</h2>
+
+<table class="spectable standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.__lookupGetter__', 'Object.prototype.__lookupGetter__()')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Incluído no (normativo) anexo para ECMAScript adicional recurso para Web (note que a especificação codificada está tendo implementações).</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nessa página é gerado de data estruturada. Se você gostaria de contribuir para a data, por favor confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie para nós uma solicitação.</div>
+
+<p>{{Compat("javascript.builtins.Object.lookupGetter")}}</p>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.__lookupSetter__()")}}</li>
+ <li>{{jsxref("Functions/get", "get")}} operador</li>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}} e {{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.prototype.__defineGetter__()")}}</li>
+ <li>{{jsxref("Object.prototype.__defineSetter__()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">JS Guide: Defining Getters and Setters</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/__lookupsetter__/index.html b/files/pt-br/web/javascript/reference/global_objects/object/__lookupsetter__/index.html
new file mode 100644
index 0000000000..a84545880f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/__lookupsetter__/index.html
@@ -0,0 +1,92 @@
+---
+title: Object.prototype.__lookupSetter__()
+slug: Web/JavaScript/Reference/Global_Objects/Object/__lookupSetter__
+tags:
+  - Deprecated
+  - Depreciado
+  - JavaScript
+  - Method
+  - Object
+  - Objeto
+  - Prototipo
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/__lookupSetter__
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code><strong>__lookupSetter__</strong></code> retorna a função vinculada como <em>setter</em> para a propriedade especificada.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>obj</var>.__lookupSetter__(<var>sprop</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>sprop</code></dt>
+ <dd>Uma cadeia de caracteres (<em>string</em>) contendo o nome da propriedade a qual o <em>setter</em> deve ser retornado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>A função vinculada como <em>setter</em> para a propriedade especificada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se o <em>setter</em> foi definido para uma propriedade do objeto, não era possível referenciar a função através da propriedade, porque aquela propriedade se refere ao valor de retorno da função. <code>__lookupSetter__</code> pode ser usado para obter a referência para a função <em>setter</em>.</p>
+
+<p>É possível agora fazer isso de forma padronizada usando {{jsxref("Object.getOwnPropertyDescriptor()")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Formas_compatíveis_e_não_padronizadas_de_obter_um_definidor_de_propriedades">Formas compatíveis e não padronizadas de obter um definidor de propriedades</h3>
+
+<pre class="brush: js notranslate">var obj = {
+  set foo(value) {
+    this.bar = value;
+  }
+};
+
+
+// Forma não padronizada e depreciada
+obj.__lookupSetter__('foo')
+// (function(value) { this.bar = value; })
+
+
+// Forma compatível padronizada
+Object.getOwnPropertyDescriptor(obj, 'foo').set;
+// (function(value) { this.bar = value; })
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="spectable standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.__lookupSetter__', 'Object.prototype.__lookupSetter__()')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.lookupSetter")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.__lookupGetter__()")}}</li>
+ <li>Operador {{jsxref("Functions/set", "set")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}} e {{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.prototype.__defineGetter__()")}}</li>
+ <li>{{jsxref("Object.prototype.__defineSetter__()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters">JS Guide: Defining Getters and Setters</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/assign/index.html b/files/pt-br/web/javascript/reference/global_objects/object/assign/index.html
new file mode 100644
index 0000000000..87d62130d2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/assign/index.html
@@ -0,0 +1,223 @@
+---
+title: Object.assign()
+slug: Web/JavaScript/Reference/Global_Objects/Object/assign
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Method
+  - Object
+  - Reference
+  - polyfill
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/assign
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Object.assign()</code></strong> é usado para copiar os valores de todas as propriedades próprias enumeráveis de um ou mais objetos <em>de origem</em> para um objeto <em>destino</em>. Este método irá retornar o objeto <em>destino</em>.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/object-assign.html")}}</p>
+
+<div class="hidden">
+<p>The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples and</a> send us a pull request.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.assign(<var>destino</var>, ...<em>origens</em>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>destino</code></dt>
+ <dd>O objeto <em>destino</em>.</dd>
+ <dt><code>origens</code></dt>
+ <dd>Um ou mais objetos de <em>origem</em>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O objeto <em>destino</em> será retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Object.assign()</code> copia apenas propriedades <em>enumeráveis</em><em> </em>e<em> próprias</em> de um objeto <em>de origem</em> para um objeto destino. Ele usa <code>[[Get]]</code> na origem e <code>[[Put]]</code> no <em>destino</em>, então isto irá invocar <em>getters</em> e <em>setters</em>.</p>
+
+<p>Portanto, ele <em>atribui</em> propriedades, em vez de simplesmente copiar ou definir novas propriedades. Isso pode fazê-lo impróprio para combinar novas propriedades com um <em>prototype</em> se os objetos <em>de origem</em> contiverem getters. Para copiar definições de propriedades, incluindo sua enumerabilidade, para <em>prototypes</em> {{jsxref("Object.getOwnPropertyDescriptor()")}} e {{jsxref("Object.defineProperty()")}} devem ser utilizadas no lugar.</p>
+
+<p>Ambas as propriedades {{jsxref("String")}} e {{jsxref("Symbol")}} são copiadas.</p>
+
+<p>No caso de erro, por exemplo, se uma propriedade não é <em>writable</em>, um {{jsxref("TypeError")}} será lançado e o objeto <em>destino</em> permanecerá inalterado. Note que <code>Object.assign()</code> não lança erros caso algum argumento <em>source</em> seja {{jsxref("null")}} ou {{jsxref("undefined")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Clonando_um_objeto">Clonando um objeto</h3>
+
+<pre class="brush: js">var obj = { a: 1 };
+var copy = Object.assign({}, obj);
+console.log(copy); // { a: 1 }
+</pre>
+
+<h3 id="Mesclando_objetos">Mesclando objetos</h3>
+
+<pre class="brush: js">var o1 = { a: 1 };
+var o2 = { b: 2 };
+var o3 = { c: 3 };
+
+var obj = Object.assign(o1, o2, o3);
+console.log(obj); // { a: 1, b: 2, c: 3 }
+console.log(o1);  // { a: 1, b: 2, c: 3 }, target object itself is changed.
+</pre>
+
+<h3 id="Copiando_propriedades_Symbol">Copiando propriedades Symbol</h3>
+
+<pre class="brush: js">var o1 = { a: 1 };
+var o2 = { [Symbol('foo')]: 2 };
+
+var obj = Object.assign({}, o1, o2);
+console.log(obj); // { a: 1, [Symbol("foo")]: 2 }
+</pre>
+
+<h3 id="Propriedades_herdadas_e_não_enumeráveis_não_podem_ser_copiadas">Propriedades herdadas e não enumeráveis não podem ser copiadas</h3>
+
+<pre class="brush: js">var obj = Object.create({ foo: 1 }, { // foo is an inherit property.
+  bar: {
+    value: 2  // bar is a non-enumerable property.
+  },
+  baz: {
+    value: 3,
+    enumerable: true  // baz is an own enumerable property.
+  }
+});
+
+var copy = Object.assign({}, obj);
+console.log(copy); // { baz: 3 }
+</pre>
+
+<h3 id="Primitivas_serão_encapsuladas_em_objetos">Primitivas serão encapsuladas em objetos</h3>
+
+<pre class="brush: js">var v1 = '123';
+var v2 = true;
+var v3 = 10;
+var v4 = Symbol('foo')
+
+var obj = Object.assign({}, v1, null, v2, undefined, v3, v4);
+// Primitives will be wrapped, null and undefined will be ignored.
+// Note, only string wrappers can have own enumerable properties.
+console.log(obj); // { "0": "1", "1": "2", "2": "3" }
+</pre>
+
+<h3 id="Exceções_irão_interromper_a_tarefa_de_cópia_em_execução">Exceções irão interromper a tarefa de cópia em execução</h3>
+
+<pre class="brush: js">var target = Object.defineProperty({}, 'foo', {
+  value: 1,
+  writeable: false
+}); // target.foo is a read-only property
+
+Object.assign(target, { bar: 2 }, { foo2: 3, foo: 3, foo3: 3 }, { baz: 4 });
+// TypeError: "foo" is read-only
+// The Exception is thrown when assigning target.foo
+
+console.log(target.bar);  // 2, the first source was copied successfully.
+console.log(target.foo2); // 3, the first property of the second source was copied successfully.
+console.log(target.foo);  // 1, exception is thrown here.
+console.log(target.foo3); // undefined, assign method has finished, foo3 will not be copied.
+console.log(target.baz);  // undefined, the third source will not be copied either.
+</pre>
+
+<h3 id="Copiando_acessores">Copiando acessores</h3>
+
+<pre class="brush: js">var obj = {
+  foo: 1,
+  get bar() {
+    return 2;
+  }
+};
+
+var copy = Object.assign({}, obj);
+console.log(copy);
+// { foo: 1, bar: 2 }, the value of copy.bar is obj.bar's getter's return value.
+
+// This is an assign function which can copy accessors.
+function myAssign(target, ...sources) {
+  sources.forEach(source =&gt; {
+    Object.defineProperties(target, Object.keys(source).reduce((descriptors, key) =&gt; {
+      descriptors[key] = Object.getOwnPropertyDescriptor(source, key);
+      return descriptors;
+    }, {}));
+  });
+  return target;
+}
+
+var copy = myAssign({}, obj);
+console.log(copy);
+// { foo:1, get bar() { return 2 } }
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Este polyfill não suporta propriedades {{jsxref("Symbol")}}, visto que ES5 não possui símbolos:</p>
+
+<pre class="brush: js">if (!Object.assign) {
+  Object.defineProperty(Object, 'assign', {
+    enumerable: false,
+    configurable: true,
+    writable: true,
+    value: function(target) {
+      'use strict';
+      if (target === undefined || target === null) {
+        throw new TypeError('Cannot convert first argument to object');
+      }
+
+      var to = Object(target);
+      for (var i = 1; i &lt; arguments.length; i++) {
+        var nextSource = arguments[i];
+        if (nextSource === undefined || nextSource === null) {
+          continue;
+        }
+        nextSource = Object(nextSource);
+
+        var keysArray = Object.keys(Object(nextSource));
+        for (var nextIndex = 0, len = keysArray.length; nextIndex &lt; len; nextIndex++) {
+          var nextKey = keysArray[nextIndex];
+          var desc = Object.getOwnPropertyDescriptor(nextSource, nextKey);
+          if (desc !== undefined &amp;&amp; desc.enumerable) {
+            to[nextKey] = nextSource[nextKey];
+          }
+        }
+      }
+      return to;
+    }
+  });
+}
+</pre>
+
+<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>{{SpecName('ES2015', '#sec-object.assign', 'Object.assign')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<div class="hidden">
+<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+</div>
+
+<p>{{Compat("javascript.builtins.Object.assign")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperties()")}}</li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Enumerabilidade_e_posse_de_propriedades">Enumerabilidade e posse de propriedades</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/constructor/index.html b/files/pt-br/web/javascript/reference/global_objects/object/constructor/index.html
new file mode 100644
index 0000000000..4a0729a84f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/constructor/index.html
@@ -0,0 +1,192 @@
+---
+title: Object.prototype.constructor
+slug: Web/JavaScript/Reference/Global_Objects/Object/constructor
+tags:
+  - Constructor
+  - Objeto
+  - Propriedade
+  - object.constructor
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/constructor
+---
+<div>{{JSRef("Global_Objects", "Object")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>Retorna uma referência para a função {{jsxref("Global_Objects/Object", "Object")}} que cria a instância do protótipo. Note que o valor desse protótipo é uma referência para a própria função, não uma string contendo o nome da função. O valor é apenas <em>read-only</em> para valores primitivos como <code>1</code>, <code>true</code> e <code>"test"</code>.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Todos os objetos herdam a propriedade <em>construtor</em> de seu protótipo:</p>
+
+<pre class="brush: js">var o = {};
+o.constructor === Object; // true
+
+var a = [];
+a.constructor === Array; // true
+
+var n = new Number(3);
+n.constructor === Number; // true
+</pre>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Displaying_the_constructor_of_an_object" name="Example:_Displaying_the_constructor_of_an_object">Exemplo: Apresentando o construtor de um objeto</h3>
+
+<p>O exemplo a seguir cria um protótipo, <code>Tree</code>, e um objeto desse tipo, <code>theTree</code>. O exemplo, então, apresenta a propriedade <em>constructor </em>do objeto <code>theTree</code>.</p>
+
+<pre class="brush: js">function Tree(name) {
+  this.name = name;
+}
+
+var theTree = new Tree('Redwood');
+console.log('theTree.constructor is ' + theTree.constructor);
+</pre>
+
+<p>Esse exemplo apresenta a seguinte saída:</p>
+
+<pre class="brush: js">theTree.constructor is function Tree(name) {
+  this.name = name;
+}
+</pre>
+
+<h3 id="Example:_Changing_the_constructor_of_an_object" name="Example:_Changing_the_constructor_of_an_object">Exemplo: Mudando o construtor de um objeto</h3>
+
+<p>O exemplo a seguir apresenta como modificar o valor do construtor de um objeto genérico. Apenas <code>true</code>, <code>1</code> e <code>"test" </code>não serão afetados sendo que eles tem <code>construtores </code><em>read-only</em> nativos. Esse exemplo apresenta que nem sempre é seguro depender da propriedade <code>constructor</code> de um objeto.</p>
+
+<pre class="brush:js">function Type () {}
+
+var types = [
+  new Array(),
+  [],
+  new Boolean(),
+  true,             // remains unchanged
+  new Date(),
+  new Error(),
+  new Function(),
+  function () {},
+  Math,
+  new Number(),
+  1,                // remains unchanged
+  new Object(),
+  {},
+  new RegExp(),
+  /(?:)/,
+  new String(),
+  'test'            // remains unchanged
+];
+
+for (var i = 0; i &lt; types.length; i++) {
+  types[i].constructor = Type;
+  types[i] = [types[i].constructor, types[i] instanceof Type, types[i].toString()];
+}
+
+console.log(types.join('\n'));
+</pre>
+
+<p>Esse exemplo apresenta a seguinte saída:</p>
+
+<pre class="brush: js">function Type() {},false,
+function Type() {},false,
+function Type() {},false,false
+function Boolean() {
+    [native code]
+},false,true
+function Type() {},false,Mon Sep 01 2014 16:03:49 GMT+0600
+function Type() {},false,Error
+function Type() {},false,function anonymous() {
+
+}
+function Type() {},false,function () {}
+function Type() {},false,[object Math]
+function Type() {},false,0
+function Number() {
+    [native code]
+},false,1
+function Type() {},false,[object Object]
+function Type() {},false,[object Object]
+function Type() {},false,/(?:)/
+function Type() {},false,/(?:)/
+function Type() {},false,
+function String() {
+    [native code]
+},false,test
+</pre>
+
+<h2 id="Specifications" name="Specifications">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>ECMAScript 1ª Edição.</td>
+   <td>Padrão</td>
+   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.1', 'Object.prototype.constructor')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.constructor', 'Object.prototype.constructor')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/count/index.html b/files/pt-br/web/javascript/reference/global_objects/object/count/index.html
new file mode 100644
index 0000000000..24b13a68b8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/count/index.html
@@ -0,0 +1,46 @@
+---
+title: Object.prototype.__count__
+slug: Web/JavaScript/Reference/Global_Objects/Object/count
+tags:
+  - JavaScript
+  - Não-padronizado
+  - Objeto
+  - Obsoleto
+  - Propriedade
+  - Prototipo
+  - Prototype
+translation_of: Archive/Web/JavaScript/Object.count
+---
+<div>{{JSRef}}{{Non-standard_Header}}{{obsolete_header("gecko2")}}</div>
+
+<p>A propriedade <strong><code>__count__</code></strong> usada para armazenar a contagem de propriedades enumeráveis sobre o objeto, mas ele foi removido.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>obj</var>.__count__</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">{ 1: 1 }.__count__              // 1
+[].__count__                    // 0
+[1].__count__                   // 1
+[1, /* hole */, 2, 3].__count__ // 3
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de qualquer especificação.</p>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.count")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a class="external" href="http://whereswalden.com/2010/04/06/more-changes-coming-to-spidermonkey-the-magical-__count__-property-of-objects-is-being-removed/">[Blog post] Mais trocas vindo para SpiderMonkey: a mágica propriedade __count__ está sendo removid</a>a</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/create/index.html b/files/pt-br/web/javascript/reference/global_objects/object/create/index.html
new file mode 100644
index 0000000000..9c37fa8fcc
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/create/index.html
@@ -0,0 +1,260 @@
+---
+title: Object.create()
+slug: Web/JavaScript/Reference/Global_Objects/Object/create
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/create
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.create()</strong></code> cria um novo objeto, utilizando um outro objecto existente como protótipo para o novo objeto a ser criado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.create(<var>proto</var>[, <var>propertiesObject</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>proto</code></dt>
+ <dd>O objeto que deve ser o protótipo do objeto recém-criado.</dd>
+ <dt><code>propertiesObject</code></dt>
+ <dd>Opcional. Se especificado e não {{jsxref("undefined")}}, um objeto cuja as propriedades próprias enumeráveis (isto é, aquelas propriedades definidas sobre si mesmo, e <em>não</em> propriedades enumeráveis ao longo da sua cadeia protótipa) especificam os nomes das propriedades a serem adicionadas ao objeto recém-criado, com os nomes das propriedades correspondentes. Essas propriedades correspondem ao segundo argumento de {{jsxref("Object.defineProperties()")}}.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um novo objeto com o protótipo de objeto e propriedades especificadas.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<p>Uma exceção {{jsxref("TypeError")}} se o parâmetro <code>proto</code> não for {{jsxref("null")}} ou um objeto.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Herança_tradicional_com_Object.create()">Herança tradicional com <code>Object.create()</code></h3>
+
+<p>A seguir, um exemplo de como usar <code>Object.create()</code> para realizar uma herança tradicional. Isto é para herança simples, que é a única herança suportada pelo JavaScript.</p>
+
+<pre class="brush: js">// Shape - superclasse
+function Shape() {
+  this.x = 0;
+  this.y = 0;
+}
+
+// método da superclasse
+Shape.prototype.move = function(x, y) {
+  this.x += x;
+  this.y += y;
+  console.info('Shape moved.');
+};
+
+// Rectangle - subclasse
+function Rectangle() {
+  Shape.call(this); // chama construtor-pai.
+}
+
+// subclasse extende superclasse
+Rectangle.prototype = Object.create(Shape.prototype);
+Rectangle.prototype.constructor = Rectangle;
+
+var rect = new Rectangle();
+
+console.log('Rect é uma instância de Rectangle?', rect instanceof Rectangle);// true
+console.log('Rect é uma instância de Shape?', rect instanceof Shape);// true
+rect.move(1, 1); // Saída: 'Shape moved.'
+</pre>
+
+<p>Caso queira realizar herança de múltiplos objetos, então mixins ("mistura") são uma possibilidade.</p>
+
+<pre class="brush: js">function MyClass() {
+  SuperClass.call(this);
+  OtherSuperClass.call(this);
+}
+
+MyClass.prototype = Object.create(SuperClass.prototype); // herança
+mixin(MyClass.prototype, OtherSuperClass.prototype); // mixin
+
+MyClass.prototype.myMethod = function() {
+  // faz algo
+};
+</pre>
+
+<p>A função <code>mixin</code> copia as funções do protótipo da superclasse para o protótipo da subclasse, a função mixin precisa ser fornecida pelo usuário. Um exemplo de uma função do tipo mixin seria <a href="https://api.jquery.com/jQuery.extend/">jQuery.extend()</a>.</p>
+
+<h3 id="Usando_argumento_propertiesObject_com_Object.create()">Usando argumento <code>propertiesObject</code> com <code>Object.create()</code></h3>
+
+<pre class="brush: js">var o;
+
+// cria um objeto com protótipo null
+o = Object.create(null);
+
+
+o = {};
+// equivalente a:
+o = Object.create(Object.prototype);
+
+
+// Exemplo em que criamos um objeto com algumas propriedades
+// (Note que o segundo parâmetro mapeia as chaves para *descritores de propriedade*.)
+o = Object.create(Object.prototype, {
+  // foo é uma 'propriedade de valor' ('value property') normal
+  foo: { writable: true, configurable: true, value: 'hello' },
+  // bar é uma propriedade getter-setter (accessor)
+  bar: {
+    configurable: false,
+    get: function() { return 10; },
+    set: function(value) { console.log('Setting `o.bar` to', value); }
+/* com os ES5 Accessors nosso código pode ser escrito como:
+    get function() { return 10; },
+    set function(value) { console.log('setting `o.bar` to', value); } */
+  }
+});
+
+
+function Constructor() {}
+o = new Constructor();
+// equivalente a:
+o = Object.create(Constructor.prototype);
+// Claro, se há de fato um código de inicialização na função
+// Constructor, o Object.create() não pode refleti-la
+
+
+// Cria um novo objeto cujo protóptipo é um objeto novo, vazio
+// e adiciona a propriedade 'p' com o valor 42.
+o = Object.create({}, { p: { value: 42 } });
+
+// por padrão, propriedades NÃO SÃO escritas, enumeradas ou configuráveis:
+o.p = 24;
+o.p;
+// 42
+
+o.q = 12;
+for (var prop in o) {
+  console.log(prop);
+}
+// 'q'
+
+delete o.p;
+// false
+
+// especificar uma propriedade ES3
+o2 = Object.create({}, {
+  p: {
+    value: 42,
+    writable: true,
+    enumerable: true,
+    configurable: true
+  }
+});
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Este polyfill cobre o caso de uso principal que é a crição de um novo objeto em que o protótipo foi escolhido mas não leva em consideração o segundo argumento.</p>
+
+<p>Note que, enquanto a configuração  <code>null</code> as <code>[[Prototype]]</code> é suportada no ES5 <code>Object.create</code>, este polyfill não suporta devido à limitação inerente em versões do ECMAScript inferiores a 5.</p>
+
+<pre class="brush: js">if (typeof Object.create != 'function') {
+  Object.create = (function() {
+    var Temp = function() {};
+    return function (prototype) {
+      if (arguments.length &gt; 1) {
+        throw Error('Second argument not supported');
+      }
+      if (typeof prototype != 'object') {
+        throw TypeError('Argument must be an object');
+      }
+      Temp.prototype = prototype;
+      var result = new Temp();
+      Temp.prototype = null;
+      return result;
+    };
+  })();
+}</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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.5', 'Object.create')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.create', 'Object.create')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.create', 'Object.create')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("11.60")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatOperaMobile("11.5")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.defineProperties()")}}</li>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>Post de John Resig sobre <a href="http://ejohn.org/blog/objectgetprototypeof/">getPrototypeOf()</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/defineproperties/index.html b/files/pt-br/web/javascript/reference/global_objects/object/defineproperties/index.html
new file mode 100644
index 0000000000..da7ca6540a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/defineproperties/index.html
@@ -0,0 +1,233 @@
+---
+title: Object.defineProperties()
+slug: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
+tags:
+  - ECMAScript5
+  - JavaScript
+  - Objeto
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperties
+---
+<div>{{JSRef}}</div>
+
+<p>O método  <code><strong>Object.defineProperties()</strong></code> define uma nova propriedade ou modifica uma existente no objeto, retornando o objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.defineProperties(<var>obj</var>, <var>props</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto no qual se cria ou modifica suas propriedades.</dd>
+ <dt><code>props</code></dt>
+ <dd>Um objeto do qual propriedades enumeráveis constitui descritores para as propriedades serem definidas ou modificadas. Descritores de propriedade presente nos objetos provém em dois principais tipos: descritores de dados e de acesso (veja {{jsxref("Object.defineProperty()")}} para mais detalhes). Descritores têm as seguintes chaves:</dd>
+ <dd>
+ <dl>
+  <dt><code>configurable</code></dt>
+  <dd><code>true</code> se e somente se o tipo deste descritor de propriedades pode ser modificada e se a propriedade pode ser apagada do objeto correspondente.<br>
+  <strong>Valor padrão é <code>false</code>.</strong></dd>
+  <dt><code>enumerable</code></dt>
+  <dd><code>true</code> se e somente se este propriedade aparece durante enumeração das propriedade sobre o objeto correspondente.<br>
+  <strong>Valor padrão é <code>false</code>.</strong></dd>
+ </dl>
+
+ <dl>
+  <dt><code>value</code></dt>
+  <dd>O valor associado com a propriedade. Pode ser qualquer valor válido em JavaScript value (número, objeto, função, etc).<br>
+  <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+  <dt><code>writable</code></dt>
+  <dd><code>true</code> se e somente se o valor associado com a propriedade pode ser modificada com um {{jsxref("Operators/Assignment_Operators", "assignment operator", "", 1)}}.<br>
+  <strong>Valor padrão é <code>false</code>.</strong></dd>
+ </dl>
+
+ <dl>
+  <dt><code>get</code></dt>
+  <dd>Uma função a qual serve com um getter para a propriedade, ou {{jsxref("undefined")}} se não existe getter. A retorno da função será usado como o valor da propriedade.<br>
+  <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+  <dt><code>set</code></dt>
+  <dd>Uma função a qual server com um setter para a propriedade, ou {{jsxref("undefined")}} se não existe setter. A função receberá como argumento somente o novo valor sendo atribuído à propriedade.<br>
+  <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+ </dl>
+ </dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto que foi passado para a função.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.defineProperties</code>, em essência, define todas as propriedades correspondentes para as propriedades próprias  enumeráveis de <code>props</code> sobre o objeto <code>obj</code>.</p>
+
+<h2 id="Exemplo">Exemplo</h2>
+
+<pre class="brush: js">var obj = {};
+Object.defineProperties(obj, {
+  'property1': {
+    value: true,
+    writable: true
+  },
+  'property2': {
+    value: 'Hello',
+    writable: false
+  }
+  // etc. etc.
+});
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Assumindo uma execução intocada com todos os nomes e propriedades referindo para seus valores iniciais, <code>Object.defineProperties</code> é quase completamente equivalente (note o comentário em <code>isCallable</code>) para a seguinte reimplementação em JavaScript:</p>
+
+<pre class="brush: js;highlight:[8]">function defineProperties(obj, properties) {
+  function convertToDescriptor(desc) {
+    function hasProperty(obj, prop) {
+      return Object.prototype.hasOwnProperty.call(obj, prop);
+    }
+
+    function isCallable(v) {
+      // NB: modify as necessary if other values than functions are callable.
+      return typeof v === 'function';
+    }
+
+    if (typeof desc !== 'object' || desc === null)
+      throw new TypeError('bad desc');
+
+    var d = {};
+
+    if (hasProperty(desc, 'enumerable'))
+      d.enumerable = !!desc.enumerable;
+    if (hasProperty(desc, 'configurable'))
+      d.configurable = !!desc.configurable;
+    if (hasProperty(desc, 'value'))
+      d.value = desc.value;
+    if (hasProperty(desc, 'writable'))
+      d.writable = !!desc.writable;
+    if (hasProperty(desc, 'get')) {
+      var g = desc.get;
+
+      if (!isCallable(g) &amp;&amp; typeof g !== 'undefined')
+        throw new TypeError('bad get');
+      d.get = g;
+    }
+    if (hasProperty(desc, 'set')) {
+      var s = desc.set;
+      if (!isCallable(s) &amp;&amp; typeof s !== 'undefined')
+        throw new TypeError('bad set');
+      d.set = s;
+    }
+
+    if (('get' in d || 'set' in d) &amp;&amp; ('value' in d || 'writable' in d))
+      throw new TypeError('identity-confused descriptor');
+
+    return d;
+  }
+
+  if (typeof obj !== 'object' || obj === null)
+    throw new TypeError('bad obj');
+
+  properties = Object(properties);
+
+  var keys = Object.keys(properties);
+  var descs = [];
+
+  for (var i = 0; i &lt; keys.length; i++)
+    descs.push([keys[i], convertToDescriptor(properties[keys[i]])]);
+
+  for (var i = 0; i &lt; descs.length; i++)
+    Object.defineProperty(obj, descs[i][0], descs[i][1]);
+
+  return obj;
+}
+</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('ES5.1', '#sec-15.2.3.7', 'Object.defineProperties')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.8.5</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.defineproperties', 'Object.defineProperties')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.defineproperties', 'Object.defineProperties')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Firefox (Gecko)</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("11.60")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>Android</th>
+   <th>Edge</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatGeckoMobile("2")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOperaMobile("11.5")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerabilidade e direito de propriedades</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/defineproperty/index.html b/files/pt-br/web/javascript/reference/global_objects/object/defineproperty/index.html
new file mode 100644
index 0000000000..25ad45b438
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/defineproperty/index.html
@@ -0,0 +1,478 @@
+---
+title: Object.defineProperty()
+slug: Web/JavaScript/Reference/Global_Objects/Object/defineProperty
+tags:
+  - ECMAScript5
+  - JavaScript
+  - Método(2)
+  - Objeto
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/defineProperty
+---
+<div>{{JSRef}}</div>
+
+<div></div>
+
+<p>O método <code><strong>Object.defineProperty()</strong></code> define uma nova propriedade diretamente em um objeto, ou modifica uma propriedade já existente em um objeto, e retorna o objeto.</p>
+
+<div class="note">
+<p><strong>Nota</strong>: Você invoca este método diretamente no construtor do {{jsxref("Object")}} ao invés de invocar em uma instância do tipo <code>Object</code>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>Object.defineProperty(<var>obj</var>, <var>prop</var>, <var>descriptor</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto no qual será definida a propriedade.</dd>
+ <dt><code>prop</code></dt>
+ <dd>O nome da propriedade que será definida ou modificada.</dd>
+ <dt><code>descriptor</code></dt>
+ <dd>O descritor para a propriedade que será definida ou modificada.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto que foi passado à função.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Esse método permite uma precisa inclusão ou modificação de uma propriedade em um objeto. Enquanto a inclusão de propriedades através de atribuição cria propriedades que são visíveis durante a enumeração (por repetições {{jsxref("Statements/for...in", "for...in")}} ou pelo método {{jsxref("Object.keys")}}), e cujos valores podem ser alterados e {{jsxref("Operators/delete", "deletados", "", 1)}}, esse método permite a modificação deste comportamento padrão. Por padrão, valores incluídos utilizando <code>Object.defineProperty()</code> são imutáveis.</p>
+
+<p>Os descritores de propriedades presentes nos objetos se apresentam em duas variedades: descritores de dados e descritores de assessores. Um <em>descritor de dado</em> é uma propriedade que contém um valor, podendo este ser gravável ou não. Um <em>descritor de assessor </em>é uma propriedade definida como um par de funções getter-setter. Um descritor deve ser de uma destas variedades; não pode ser de ambas.</p>
+
+<p>Ambos os descritores de dados e de assessor são objetos. Eles compartilham as seguintes chaves obrigatórias:</p>
+
+<dl>
+ <dt><code>configurable</code></dt>
+ <dd><code>true</code> se e somente se o tipo deste descritor de propriedade pode ser alterado e se a propriedade pode ser deletada do objeto correspondente.<br>
+ <strong>Valor padrão é <code>false</code>.</strong></dd>
+ <dt><code>enumerable</code></dt>
+ <dd><code>true</code> se e somente se esta propriedade aparece durante enumeração das propriedades no objeto correspondente.<br>
+ <strong>Valor padrão é <code>false</code>.</strong></dd>
+</dl>
+
+<p>Um descritor de dados também possui as seguintes chaves opcionais:</p>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>O valor associado com a propriedade. Pode ser qualquer valor válido em Javascript  (número, objeto, função, etc).<br>
+ <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+ <dt><code>writable</code></dt>
+ <dd><code>true</code> se e somente se o valor associado com a propriedade pode ser modificada com um {{jsxref("Operators/Assignment_Operators", "operador de atribuição", "", 1)}}.<br>
+ <strong>Valor padrão é <code>false</code>.</strong></dd>
+</dl>
+
+<p>Um descritor de assessor também possui as seguintes chaves opcionais:</p>
+
+<dl>
+ <dt><code>get</code></dt>
+ <dd>Uma função que servirá como um getter da propriedade, ou {{jsxref("undefined")}} se não houver getter. Quando a propriedade é acessada, esta função é chamada sem argumentos e com <code>this</code> define para o objeto no qual a propriedade é acessada (este pode não ser o objeto sobre o qual a propriedade está definida devido a herança). O valor retornado será usado como valor da propriedade.<br>
+ <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+ <dt><code>set</code></dt>
+ <dd>A função que servirá como um setter para a propriedade, ou {{jsxref("undefined")}} se não houver setter. Quando a propriedade é atribuída, esta função é chamada com um argumento (o valor sendo atribuído para a propriedade) e com <code>this</code> configura o objeto através do qual a propriedade é atribuída.<br>
+ <strong>Valor padrão é {{jsxref("undefined")}}.</strong></dd>
+</dl>
+
+<p>Se um descritor tem  nenhum das chaves <code>value</code>, <code>writable</code>, <code>get</code> e <code>set</code>, ele é tratado como um descritor de dados. Se um descritor tem ambas chaves <code>value</code> ou <code>writable</code> e <code>get</code> ou <code>set</code> keys, uma exceção é lançada.</p>
+
+<p>Tenha em mente que estes atributos não são necessariamente as propriedades do próprio descritor. Propriedades herdadas serão consideradas também. Para garantir que estes padrões sejam preservados, você pode congelar o {{jsxref("Object.prototype")}} previamente, declarar todas as opções explicitamente, ou apontar para {{jsxref("null")}} com {{jsxref("Object.create", "Object.create(null)")}}.</p>
+
+<pre class="brush: js notranslate">// usando __proto__
+var obj = {};
+var descriptor = Object.create(null); // não herdar propriedades
+// não enumerável, não configurável, não gravável por padrão
+descriptor.value = 'static';
+Object.defineProperty(obj, 'key', descriptor);
+
+// declarando explicitamente
+Object.defineProperty(obj, 'key', {
+  enumerable: false,   // não enumerável
+  configurable: false, // não configurável
+  writable: false,     // não gravável
+  value: 'static'
+});
+
+// reciclando um mesmo objeto
+function withValue(value) {
+  var d = withValue.d || (
+    withValue.d = {
+      enumerable: false,
+      writable: false,
+      configurable: false,
+      value: null
+    }
+  );
+  d.value = value;
+  return d;
+}
+
+// ... e ...
+Object.defineProperty(obj, 'key', withValue('static'));
+
+// se o método freeze estiver disponível, prevenir as propriedades
+// (value, get, set, enumerable, writable, configurable) de serem
+// incluídas ou removidas do protótipo do objeto
+(Object.freeze || Object)(Object.prototype);</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Se você deseja utilizar o método <code>Object.defineProperty</code> com uma sintaxe estilo <em>flags-binárias</em>, veja os <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty/Additional_examples">exemplos adicionais</a>.</p>
+
+<h3 id="Criando_uma_propriedade">Criando uma propriedade</h3>
+
+<p>Quando a propriedade especificada não existe no objeto, <code>Object.defineProperty()</code>  cria uma nova propriedade conforme descrito anteriormente. Campos podem ser omitidos no descritor, e os valores padrão para esses campos serão introduzidos.</p>
+
+<p>Todos os campos do tipo Boolean possuem como valor padrão <code>false</code>. Os campos <code>value</code>, <code>get</code>, e <code>set</code> possuem como padrão {{jsxref("undefined")}}.  Uma propriedade que é definida sem os valores para <code>get</code>/<code>set</code>/<code>value</code>/<code>writable</code> é dita "genérica" e classificada como um descritor de dados.</p>
+
+<pre class="brush: js notranslate">var o = {}; // Criar um novo objeto
+
+// Exemplo de propriedade de objeto inserida através
+// de defineProperty com descritor do tipo dado
+Object.defineProperty(o, 'a', {
+  value: 37,
+  writable: true,
+  enumerable: true,
+  configurable: true
+});
+// A propriedade 'a' existe no objeto com valor 37
+
+// Exemplo de propriedade de objeto inserida através
+// de defineProperty com descritor do tipo assessor
+var bValue = 38;
+
+Object.defineProperty(o, 'b', {
+  get: function() { return bValue; },
+  set: function(newValue) { bValue = newValue; },
+  enumerable: true,
+  configurable: true
+});
+
+o.b; // 38
+// A propriedade 'b' existe no objeto com valor 38
+// O valor de o.b será sempre idêntico a bValue, a
+// menos que o.b seja redefinido
+
+// Você não pode combinar ambos os tipos:
+Object.defineProperty(o, 'conflict', {
+  value: 0x9f91102,
+  get: function() { return 0xdeadbeef; }
+});
+// lança um TypeError: value existe apenas em descritores
+// de dado, get existe apenas em descritores de assessor</pre>
+
+<h3 id="Modificando_uma_propriedade">Modificando uma propriedade</h3>
+
+<p>Quando uma propriedade já existe, <code>Object.defineProperty()</code> tenta modificá-la de acordo com os valores do descritor e a configuração atual do objeto. Se o descritor antigo possuía seu atributo <code>configurable</code> como <code>false</code> a propriedade é chamada "não configurável" e nenhum atributo pode ser alterado <font face="consolas, Liberation Mono, courier, monospace">(exceto a alteração irreversível de <em>writable </em>para <em>false</em>)</font>. Não é possível alternar o tipo de uma propriedade entre dados e assessor quando esta for não-configurável.</p>
+
+<p>Um {{jsxref("TypeError")}} é lançado quando são realizadas tentativas de se alterar propriedades não-configuráveis (exceto o atributo <code>writable</code>) a menos que o valor atual e o novo sejam os mesmos.</p>
+
+<h4 id="O_atributo_writable">O atributo writable</h4>
+
+<p>Quando o atributo <code>writable</code> de uma propriedade é definido como <code>false</code>, a propriedade é dita "não-gravável". Seu valor não poderá ser alterado.</p>
+
+<pre class="brush: js notranslate">var o = {}; // Cria um novo objeto
+
+Object.defineProperty(o, 'a', {
+  value: 37,
+  writable: false
+});
+
+console.log(o.a); // escreve 37
+
+o.a = 25; // Nenhum erro é lançado (no modo strict seria
+          // lançado mesmo que o valor fosse o mesmo)
+
+console.log(o.a); // escreve 37. A atribuição não teve efeito.</pre>
+
+<p>Como visto no exemplo, tentativas de escrita em uma propriedade não-gravável não alteram seu valor, mas também não lançam erros.</p>
+
+<h4 id="O_atributo_enumerable">O atributo enumerable</h4>
+
+<p>O atributo <code>enumerable</code> de uma propriedade define se ela deve ser exibida em uma repetição {{jsxref("Statements/for...in", "for...in")}} e por {{jsxref("Object.keys()")}} ou não.</p>
+
+<pre class="brush: js notranslate">var o = {};
+
+Object.defineProperty(o, 'a', {
+  value: 1,
+  enumerable: true
+});
+
+Object.defineProperty(o, 'b', {
+  value: 2,
+  enumerable: false
+});
+
+Object.defineProperty(o, 'c', {
+  value: 3
+}); // o valor padrão para enumerable é false
+
+o.d = 4; // o valor padrão para enumerable é true quando
+         // a propriedade é criada em uma atribuição
+
+for (var i in o) {
+  console.log(i);
+}
+// escreve 'a' e 'd' (em ordem indefinida)
+
+Object.keys(o); // ['a', 'd']
+
+o.propertyIsEnumerable('a'); // true
+o.propertyIsEnumerable('b'); // false
+o.propertyIsEnumerable('c'); // false</pre>
+
+<h4 id="O_atributo_configurable">O atributo configurable</h4>
+
+<p>O atributo <code>configurable</code> controla ao mesmo se uma propriedade pode ser deletada do objeto, e se seus atributos (exceto a mudança de <code>writable</code> para <code>false</code>) podem ser alterados.</p>
+
+<pre class="brush: js notranslate">var o = {};
+
+Object.defineProperty(o, 'a', {
+  get: function() { return 1; },
+  configurable: false
+});
+
+Object.defineProperty(o, 'a', {
+  configurable: true
+}); // lança um TypeError
+
+Object.defineProperty(o, 'a', {
+  enumerable: true
+}); // lança um TypeError
+
+Object.defineProperty(o, 'a', {
+  set: function() {}
+}); // lança um TypeError (o atributo set já estava definido)
+
+Object.defineProperty(o, 'a', {
+  get: function() { return 1; }
+}); // lança um TypeError
+    // (mesmo o novo get fazendo exatamente a mesma coisa)
+
+Object.defineProperty(o, 'a', {
+  value: 12
+}); // lança um TypeError
+
+console.log(o.a); // escreve 1
+delete o.a; // Nada acontece
+console.log(o.a); // escreve 1</pre>
+
+<p>Se o atributo <code>configurable</code> de <code>o.a</code> fosse <code>true</code>, nenhum dos erros seria lançado e a propriedade estaria deletada ao final.</p>
+
+<h3 id="Incluindo_propriedades_e_valores_padrão">Incluindo propriedades e valores padrão</h3>
+
+<p>É importante considerar a forma como os valores padrão para atributos são aplicados. Normalmente existe diferença entre usar a notação por ponto para atribuir um valor e usar <code>Object.defineProperty()</code>, como pode ser visto no exemplo abaixo:</p>
+
+<pre class="brush: js notranslate">var o = {};
+
+o.a = 1;
+
+// é equivalente a:
+Object.defineProperty(o, 'a', {
+  value: 1,
+  writable: true,
+  configurable: true,
+  enumerable: true
+});
+
+// Por outro lado,
+Object.defineProperty(o, 'a', { value: 1 });
+
+// é equivalente a:
+Object.defineProperty(o, 'a', {
+  value: 1,
+  writable: false,
+  configurable: false,
+  enumerable: false
+});</pre>
+
+<h3 id="Setters_e_getters_customizados">Setters e getters customizados</h3>
+
+<p>O exemplo abaixo mostra como implementar um objeto auto-arquivável. Quando a propriedade <code>temperature</code> é atribuída, o array <code>archive</code> recebe uma nova entrada de log.</p>
+
+<pre class="brush: js notranslate">function Archiver() {
+  var temperature = null;
+  var archive = [];
+
+  Object.defineProperty(this, 'temperature', {
+    get: function() {
+      console.log('get!');
+      return temperature;
+    },
+    set: function(value) {
+      temperature = value;
+      archive.push({ val: temperature });
+    }
+  });
+
+  this.getArchive = function() { return archive; };
+}
+
+var arc = new Archiver();
+arc.temperature; // 'get!'
+arc.temperature = 11;
+arc.temperature = 13;
+arc.getArchive(); // [{ val: 11 }, { val: 13 }]</pre>
+
+<p>Neste exemplo, um getter sempre returna o mesmo valor.</p>
+
+<pre class="brush: js notranslate">var pattern = {
+    get: function () {
+        return 'Eu sempre retorno esta string, ' +
+               'não importa o que você atribuiu';
+    },
+    set: function () {
+        this.myname = 'esta string é meu nome';
+    }
+};
+
+function TestDefineSetAndGet() {
+    Object.defineProperty(this, 'myproperty', pattern);
+}
+
+var instance = new TestDefineSetAndGet();
+instance.myproperty = 'test';
+
+console.log(instance.myproperty);
+// Eu sempre retorno esta string, não importa o que você atribuiu
+
+console.log(instance.myname); // esta string é meu nome
+</pre>
+
+<h3 id="Propriedades_de_Herança">Propriedades de Herança </h3>
+
+<p>Se uma propriedade de acessor é herdada, métodos <code>get</code> e <code>set</code> serão chamados quando a propriedade é acessada e modificada sobre os objetos descendentes. Se estes métodos usam uma variável para armazenar o valor, este valor será compartilhada por todos os objetos.</p>
+
+<pre class="notranslate"><code>function myclass() {
+}
+
+var value;
+Object.defineProperty(myclass.prototype, "x", {
+  get() {
+    return value;
+  },
+  set(x) {
+    value = x;
+  }
+});
+
+var a = new myclass();
+var b = new myclass();
+a.x = 1;
+console.log(b.x); // 1</code></pre>
+
+<p>Isto pode ser corrigido armazenando o valor em outra propriedade. Em métodos <code>get</code> e <code>set</code>, <code>this</code> aponta para o objeto no qual é usado para acessar ou modificar a propriedade.</p>
+
+<pre class="notranslate"><code>function myclass() {
+}
+
+Object.defineProperty(myclass.prototype, "x", {
+  get() {
+    return this.stored_x;
+  },
+  set(x) {
+    this.stored_x = x;
+  }
+});
+
+var a = new myclass();
+var b = new myclass();
+a.x = 1;
+console.log(b.x); // undefined</code></pre>
+
+<p>Ao contrário das propriedades do acessor, propriedades do valor serão sempre configuradas sobre  o próprio objeto, não sobre um protótipo. Entretanto, se uma propriedade de valor não-gravável é herdada, ele ainda previne de modicação a propriedade do objeto.</p>
+
+<pre class="notranslate"><code>function myclass() {
+}
+
+myclass.prototype.x = 1;
+Object.defineProperty(myclass.prototype, "y", {
+  writable: false,
+  value: 1
+});
+
+var a = new myclass();
+a.x = 2;
+console.log(a.x); // 2
+console.log(myclass.prototype.x); // 1
+a.y = 2; // Ignorado, lança no modo strict
+console.log(a.y); // 1
+console.log(myclass.prototype.y); // 1</code>
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table>
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.6', 'Object.defineProperty')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.defineproperty', 'Object.defineProperty')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.defineproperty', 'Object.defineProperty')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browser">Compatibilidade de browser</h2>
+
+<div class="hidden">
+<p>A tabela de compatibilidade nesta página é gerada à partir de dados estruturados. Se você quiser contribuir, consulte <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande uma requisição de pull.</p>
+</div>
+
+<p>{{Compat("javascript.builtins.Object.defineProperty")}}</p>
+
+<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
+
+<h3 id="Redefinindo_a_propriedade_length_de_um_objeto_Array">Redefinindo a propriedade <code>length</code> de um objeto <code>Array</code> </h3>
+
+<p>É possível redefinir a propriedade {{jsxref("Array.length", "length")}} de arrays, sujeita às restrições de redefinição usuais. (A propriedade {{jsxref("Array.length", "length")}} é inicialmente não configurável, não enumerável, mas gravável. Assim, em um array que não foi modificado, é possível alterar o valor da propriedade {{jsxref("Array.length", "length")}} ou torná-la não-gravável. Não é permitido alterar sua enumerabilidade ou configurabilidade, ou quando se encontrar não-gravável, alterar seu valor ou torná-la gravável novamente.) Entretanto, nem todos os browsers permitem esta redefinição.</p>
+
+<p>Das versões 4 até 22 do Firefox, um {{jsxref("TypeError")}} é lançado em qualquer tentativa (seja ela permitida ou não) de redefinir a propriedade {{jsxref("Array.length", "length")}} de um array.</p>
+
+<p>Versões do Chrome que implementam <code>Object.defineProperty()</code> em algumas circunstâncias ignoram um valor para <em>length</em> diferente do valor atual da propriedade {{jsxref("Array.length", "length")}} do array. Em algumas circustâncias, alterar o atributo <code>writable</code> falha de forma silenciosa (sem lançar uma exceção). Além disso, alguns métodos que modificam o array como {jsxref("Array.prototype.push")}} não respeitam uma propriedade <em>length</em> não-gravável.</p>
+
+<p>Versões do Safari que implementam <code>Object.defineProperty()</code> ignoram um valor para <code>length</code> diferente do valor atual da propriedade {{jsxref("Array.length", "length")}}, e tentantivas de alterar o atributo <code>writable</code> executam sem erros embora não modifiquem seu comportamento.</p>
+
+<p>Apenas o Internet Explorer 9 a posteriores, e o Firefox 23 e posteriores, parecem implementar total e corretamente a redefinição da propriedade {{jsxref("Array.length", "length")}} de arrays. Por enquanto, não confie que a redefinição da propriedade {{jsxref("Array.length", "length")}} vá funcionar, mesmo que de uma forma particular. E mesmo quando você <em>puder </em>confiar, <a href="http://whereswalden.com/2013/08/05/new-in-firefox-23-the-length-property-of-an-array-can-be-made-non-writable-but-you-shouldnt-do-it/">existem boas razões para não fazer isso</a>.</p>
+
+<h3 id="Notas_específicas_para_o_Internet_Explorer_8">Notas específicas para o Internet Explorer 8</h3>
+
+<p>O Internet Explorer 8 implementa o método <code>Object.defineProperty()</code> para uso <a href="https://msdn.microsoft.com/en-us/library/dd229916%28VS.85%29.aspx">apenas em objetos DOM</a>. Algumas observações:</p>
+
+<ul>
+ <li>Tentativas de usar <code>Object.defineProperty()</code> em objetos nativos lançam um erro.</li>
+ <li>Todos os atributos da propriedade devem ter seu valor definido. Os atributos <code>configurable</code>, <code>enumerable</code> e <code>writable</code> devem ser <code>true</code> para um descritor do tipo dado, e <code>true</code> para <code>configurable</code> e <code>false</code> para <code>enumerable</code> em descritores do tipo assessor. (?) Qualquer tentativa de usar outros valores (?) resultará no lançamento de um erro.</li>
+ <li>Reconfigurar uma propriedade exige que ela seja deletada anteriormente. Se a propriedade não for deletada, ela permanecerá inalterada após a tentativa de reconfiguração.</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Enumerability_and_ownership_of_properties">Enumerabilidade and posse de propriedades</a></li>
+ <li>{{jsxref("Object.defineProperties()")}}</li>
+ <li>{{jsxref("Object.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}}</li>
+ <li>{{jsxref("Object.prototype.watch()")}}</li>
+ <li>{{jsxref("Object.prototype.unwatch()")}}</li>
+ <li>{{jsxref("Operators/get", "get")}}</li>
+ <li>{{jsxref("Operators/set", "set")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty/Additional_examples">Exemplos adicionais de <code>Object.defineProperty</code></a></li>
+ <li>{{jsxref("Reflect.defineProperty()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/entries/index.html b/files/pt-br/web/javascript/reference/global_objects/object/entries/index.html
new file mode 100644
index 0000000000..1f40f3b693
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/entries/index.html
@@ -0,0 +1,110 @@
+---
+title: Object.entries()
+slug: Web/JavaScript/Reference/Global_Objects/Object/entries
+tags:
+  - Experimental
+  - JavaScript
+  - Objeto
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/entries
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>O método <code><strong>Object.entries()</strong></code> retorna uma array dos próprios pares  <code>[key, value] </code>enumeráveis de um dado objeto, na mesma ordem dos objetos providos através do loop {{jsxref("Statements/for...in", "for...in")}} (sendo a diferença que o for-in loop enumera também propriedades dispostas na cadeia de prototipagem - <em>prototype chain</em>).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">Object.entries(<var>obj</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto cujos próprios pares <code>[key, value] </code>de propriedades enumeráveis deverão ser retornados.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma array de pares <code>[key, value] </code>enumeráveis de propriedades de um dado objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.entries()</code> retorna um array cujos elementos são também arrays correspondentes aos pares de propriedades <code>[key, value] </code>enumeráveis encontrados diretamente sobre o objeto. A ordem das propriedades é a mesma que seria se fossem iteradas as propriedades do objeto manualmente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js notranslate">var obj = { foo: 'bar', baz: 42 };
+console.log(Object.entries(obj)); // [ ['foo', 'bar'], ['baz', 42] ]
+
+// objeto array-like
+var obj = { 0: 'a', 1: 'b', 2: 'c' };
+console.log(Object.entries(obj)); // [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ]
+
+// objeto array-like com ordenação aleatória de chave (key)
+var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
+console.log(Object.entries(an_obj)); // [ ['2', 'b'], ['7', 'c'], ['100', 'a'] ]
+
+// getFoo é uma propriedade que não é enumerável
+var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
+my_obj.foo = 'bar';
+console.log(Object.entries(my_obj)); // [ ['foo', 'bar'] ]
+
+// argumento não-objeto será convertido (conversão implícita) para um objeto
+console.log(Object.entries('foo')); // [ ['0', 'f'], ['1', 'o'], ['2', 'o'] ]
+
+// itera graciosamente através de chave-valor (key-value)
+var obj = {a: 5, b: 7, c: 9};
+for (var [key, value] of Object.entries(obj)) {
+    console.log(key + ' ' + value); // "a 5", "b 7", "c 9"
+}
+
+// Ou, usando array extras
+Object.entries(obj).forEach(([key, value]) =&gt; {
+    console.log(key + ' ' + value); // "a 5", "b 7", "c 9"
+});
+</pre>
+
+<h3 id="Convertendo_um_Object_em_um_Map">Convertendo um <code>Object</code> em um <code>Map</code></h3>
+
+<p>O construtor {{jsxref("Map", "new Map()")}} aceita entradas iteráveis. Com o <code>Object.entries</code>, você pode facilmente converter de {{jsxref("Object")}} para {{jsxref("Map")}}:</p>
+
+<pre class="brush: js notranslate">var obj = { foo: 'bar', baz: 42 };
+var map = new Map(Object.entries(obj));
+console.log(map); // Map { foo: "bar", baz: 42 }</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Para incluir suporte ao <code>Object.entries</code> em ambientes mais antigos, você pode achar um Polyfill nos repositórios: <a href="https://github.com/tc39/proposal-object-values-entries">tc39/proposal-object-values-entries</a> e <a href="https://github.com/es-shims/Object.entries">es-shims/Object.entries</a>.</p>
+
+<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('ESDraft', '#sec-object.entries', 'Object.entries')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<div>{{Compat("javascript.builtins.Object.entries")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerabilidade e posse de propriedades</a></li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Object.values()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/freeze/index.html b/files/pt-br/web/javascript/reference/global_objects/object/freeze/index.html
new file mode 100644
index 0000000000..b705441dee
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/freeze/index.html
@@ -0,0 +1,205 @@
+---
+title: Object.freeze()
+slug: Web/JavaScript/Reference/Global_Objects/Object/freeze
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/freeze
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.freeze()</strong></code> congela um objeto: isto é, impede que novas propriedades sejam adicionadas a ele; impede que as propriedades existentes sejam removidas; e impede que propriedades existentes, ou sua inumerabilidade, configurabilidade, ou capacidade de escrita sejam alteradas. Em essência o objeto é efetivamente imutável. O método retorna o objeto congelado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.freeze(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto a ser congelado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto congelado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Nada pode ser adicionado ou removido do conjunto de propriedades de um objeto congelado. Qualquer tentativa de fazê-lo irá falhar, ou silenciosamente ou através de um {{jsxref("TypeError")}} exception (mais frequentemente, mas não exclusivamente, quando em {{jsxref("Strict_mode", "strict mode", "", 1)}}).</p>
+
+<p>Valores não podem ser alterados para propriedades de dados. As propriedades do Accessor (getters e setters) funcionam da mesma forma (e ainda dão a ilusão de que você está alterando o valor). Observe que valores que são objetos ainda podem ser modificados, a menos que eles também sejam congelados.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var obj = {
+  prop: function() {},
+  foo: 'bar'
+};
+
+// Novas propriedades podem ser adicionadas, propriedades existentes podem ser alteradas ou removidas
+obj.foo = 'baz';
+obj.lumpy = 'woof';
+delete obj.prop;
+
+// Tanto o objeto que está sendo passado, bem como o objeto retornado será congelado.
+// É desnecessário salvar o objeto retornado para congelar o objeto original.
+var o = Object.freeze(obj);
+
+o === obj; // true
+Object.isFrozen(obj); // === true
+
+// De agora em diante qualquer alteração irá falhar
+obj.foo = 'quux'; // silenciosamente não faz nada.
+obj.quaxxor = 'the friendly duck'; // silenciosamente não adiciona a propriedade
+
+// ...e em modo strict tais tentativas irão lançar TypeErrors
+function fail(){
+  'use strict';
+  obj.foo = 'sparky'; // throws um TypeError
+  delete obj.quaxxor; // throws um TypeError
+  obj.sparky = 'arf'; // throws um TypeError
+}
+
+fail();
+
+// As tentativas de alteração através de Object.defineProperty também irão lançar
+Object.defineProperty(obj, 'ohai', { value: 17 }); // throws um TypeError
+Object.defineProperty(obj, 'foo', { value: 'eit' }); // throws um TypeError
+</pre>
+
+<p>O exemplo a seguir mostra que  valores do tipo objeto, em um objeto congelado, podem ser alterados (freeze é raso).</p>
+
+<pre class="brush: js">obj1 = {
+  internal: {}
+};
+
+Object.freeze(obj1);
+obj1.internal.a = 'aValue';
+
+obj1.internal.a // 'aValue'
+
+// Para fazer um obj completamente imutável, congele cada objeto em obj.
+// Para fazer isso, nós usamos essa função.
+function deepFreeze(obj) {
+
+  // Recuperar os nomes de propriedade definidos em obj
+  var propNames = Object.getOwnPropertyNames(obj);
+
+  // Congelar as propriedades antes de congelar-se
+  propNames.forEach(function(name) {
+    var prop = obj[name];
+
+    // Congele prop se for um objeto
+    if (typeof prop == 'object' &amp;&amp; prop !== null)
+      deepFreeze(prop);
+  });
+
+  // Congele-se (não faz nada se já estiver congelado)
+  return Object.freeze(obj);
+}
+
+obj2 = {
+  internal: {}
+};
+
+deepFreeze(obj2);
+obj2.internal.a = 'anotherValue';
+obj2.internal.a; // undefined
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>Em ES5, se um argumento para este método não for um objeto (um primitivo), então isso irá causar um {{jsxref("TypeError")}}. Em ES6, um argumento não-objeto vai ser tratado como se fosse um objeto comum congelado e simplesmente retornado.</p>
+
+<pre class="brush: js">&gt; Object.freeze(1)
+TypeError: 1 is not an object // ES5 code
+
+&gt; Object.freeze(1)
+1                             // ES6 code
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.9', 'Object.freeze')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.freeze', 'Object.freeze')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.freeze', 'Object.freeze')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Firefox (Gecko)</th>
+   <th>Chrome</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatChrome("6")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12")}}</td>
+   <td>{{CompatSafari("5.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>Android</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/fromentries/index.html b/files/pt-br/web/javascript/reference/global_objects/object/fromentries/index.html
new file mode 100644
index 0000000000..7197f0f9c0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/fromentries/index.html
@@ -0,0 +1,107 @@
+---
+title: Object.fromEntries()
+slug: Web/JavaScript/Reference/Global_Objects/Object/fromEntries
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/fromEntries
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.fromEntries()</strong></code> transforma uma lista de pares chave-valor em um objeto.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-fromentries.html")}}</div>
+
+<p class="hidden">O código para esse exemplo interativo está em um repositório GitHub repository. Se você tiver interesse em contribuir com o projeto de exemplos interativos, nos envie um <em>pull request </em>em <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Object.fromEntries(<var>iterable</var>);</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>iterable</var></code></dt>
+ <dd>Um iterável como {{jsxref("Array")}} ou {{jsxref("Map")}} ou qualquer outro objeto que implemente <a href="/pt-BR/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterable_protocol">o protocolo iterável</a>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um novo objeto com suas propriedades definidas pelas entradas fornecidadas pelo iterável.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Object.fromEntries()</code> recebe uma lista de pares chave-valor e retorna  um novo objeto cujas propriedades foram definidas pelas entradas da lista. O parâmetro <var>iterable</var> deve ser um objeto que implemente o método <code>@@iterator</code>, que retorne um objeto iterador que produza um objeto <em>array-like</em> de dois elementos, onde o primeiro será a chave da propriedade e o segundo será o valor associado à chave.</p>
+
+<p><code>Object.fromEntries()</code> faz o inverso de {{jsxref("Object.entries()")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Convertendo_um_Map_em_um_Object">Convertendo um <code>Map</code> em um <code>Object</code></h3>
+
+<p>Com o método <code>Object.fromEntries</code>, é possível fazer a conveeção de um {{jsxref("Map")}} em um {{jsxref("Object")}}:</p>
+
+<pre class="brush: js">const map = new Map([ ['foo', 'bar'], ['baz', 42] ]);
+const obj = Object.fromEntries(map);
+console.log(obj); // { foo: "bar", baz: 42 }
+</pre>
+
+<h3 id="Convertendo_um_Array_em_um_Object">Convertendo um <code>Array</code> em um <code>Object</code></h3>
+
+<p>Com o método <code>Object.fromEntries</code>, é possível converter um {{jsxref("Array")}} em um {{jsxref("Object")}}:</p>
+
+<pre class="brush: js">const arr = [ ['0', 'a'], ['1', 'b'], ['2', 'c'] ];
+const obj = Object.fromEntries(arr);
+console.log(obj); // { 0: "a", 1: "b", 2: "c" }
+</pre>
+
+<h3 id="Transformações_de_objetos">Transformações de objetos</h3>
+
+<p>Com o método <code>Object.fromEntries</code>, seu inverso {{jsxref("Object.entries()")}}, e os <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Methods_2">métodos para manipulação de arrays</a>, é possível fazer transformações em objetos como por exemplo:</p>
+
+<pre class="brush: js">const object1 = { a: 1, b: 2, c: 3 };
+
+const object2 = Object.fromEntries(
+  Object.entries(object1)
+  .map(([ key, val ]) =&gt; [ key, val * 2 ])
+);
+
+console.log(object2);
+// { a: 2, b: 4, c: 6 }</pre>
+
+<div class="hidden">
+<p>Please do not add polyfills on MDN pages. For more details, refer to: <a href="https://discourse.mozilla.org/t/mdn-rfc-001-mdn-wiki-pages-shouldnt-be-a-distributor-of-polyfills/24500">https://discourse.mozilla.org/t/mdn-rfc-001-mdn-wiki-pages-shouldnt-be-a-distributor-of-polyfills/24500</a></p>
+</div>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.fromentries', 'Object.fromEntries')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initial definition in ECMAScript 2019.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Object.fromEntries")}}</p>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Object.entries()")}}</li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Object.values()")}}</li>
+ <li>{{jsxref("Map.prototype.entries()")}}</li>
+ <li>{{jsxref("Map.prototype.keys()")}}</li>
+ <li>{{jsxref("Map.prototype.values()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
new file mode 100644
index 0000000000..fad0310e7f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptor/index.html
@@ -0,0 +1,127 @@
+---
+title: Object.getOwnPropertyDescriptor()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
+tags:
+  - ECMAScript5
+  - ECMAScript6
+  - JavaScript
+  - Método(2)
+  - Objeto
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptor
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.getOwnPropertyDescriptor()</strong></code> retorna um descritor de propriedades para uma propriedade (isto é, uma diretamente presente, e não pertencente ao objeto por força da cadeia de protótipo do objeto) de um dado objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.getOwnPropertyDescriptor(<var>obj</var>, <var>prop</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto no qual deve-se procurar pela propriedade.</dd>
+ <dt><code>prop</code></dt>
+ <dd>O nome da propriedade cuja descrição é para ser retornada.</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>Um descritor de propriedades da propriedade especificada, se esta existir no objeto, ou {{jsxref("undefined")}}, caso contrário.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Este método permite uma análise da descrição precisa de uma propriedade. Uma propriedade em Javascript consiste de um nome com formato <em>texto-valor </em>e um descritor de propriedades. Mais informações sobre os tipos de descritores de propriedades e seus atributos podem ser encontrados em {{jsxref("Object.defineProperty()")}}.</p>
+
+<p>Um descritor de propriedade é um registro com alguns dos seguintes atributos:</p>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>o valor associado com a propriedade (somente para descritores de dados).</dd>
+ <dt><code><strong>writable</strong></code></dt>
+ <dd><code>true</code> se, e somente se, o valor associado com a propriedade pode ser alterado (somente para descritores de dados).</dd>
+ <dt><code>get</code></dt>
+ <dd>Uma função que serve como um <em>getter</em>, para obter o valor da propriedade, ou {{jsxref("undefined")}} se não houver (somente para descritores de acesso).</dd>
+ <dt><code>set</code></dt>
+ <dd>Uma função que serve como um s<em>etter</em>, para atribuir um valor à propriedade, ou {{jsxref("undefined")}} se não houver (somente para descritores de acesso).</dd>
+ <dt><code>configurable</code></dt>
+ <dd><code>true</code> se, e somente se, o tipo deste descritor de propriedade pode ser alterado e se a propriedade pode ser excluída do objeto correspondente.</dd>
+ <dt><code>enumerable</code></dt>
+ <dd><code>true</code> se, e somente se, esta propriedade aparece durante a enumeração das propriedades do objeto correspondente.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var o, d;
+
+o = { get foo() { return 17; } };
+d = Object.getOwnPropertyDescriptor(o, 'foo');
+// d é { configurable: true, enumerable: true, get: /*A função <em>getter</em>*/, set: undefined }
+
+o = { bar: 42 };
+d = Object.getOwnPropertyDescriptor(o, 'bar');
+// d é { configurable: true, enumerable: true, value: 42, writable: true }
+
+o = {};
+Object.defineProperty(o, 'baz', { value: 8675309, writable: false, enumerable: false });
+d = Object.getOwnPropertyDescriptor(o, 'baz');
+// d é { value: 8675309, writable: false, enumerable: false, configurable: false }
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, o primeiro parâmetro deste método não é um objeto (tipo primitivo), então ele irá gerar um {{jsxref("TypeError")}}. No ES6, um primeiro argumento não-objeto será primeiramente convertido para objeto.</p>
+
+<pre class="brush: js">Object.getOwnPropertyDescriptor("foo", 0);
+// TypeError: "foo" is not an object  // Código ES5
+
+Object.getOwnPropertyDescriptor("foo", 0);
+// {configurable:false, enumerable:true, value:"f", writable:false}  // Código ES6
+</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('ES5.1', '#sec-15.2.3.3', 'Object.getOwnPropertyDescriptor')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.getownpropertydescriptor', 'Object.getOwnPropertyDescriptor')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<div>
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.getOwnPropertyDescriptor")}}</p>
+</div>
+</div>
+
+<p> </p>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li>{{jsxref("Reflect.getOwnPropertyDescriptor()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.html
new file mode 100644
index 0000000000..b12a764811
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertydescriptors/index.html
@@ -0,0 +1,104 @@
+---
+title: Object.getOwnPropertyDescriptors()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyDescriptors
+---
+<div>{{JSRef}}</div>
+
+<p>O <code><strong>Object.getOwnPropertyDescriptors()</strong></code> método retorna todas as descrições próprias da propriedade de um dado objeto.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-getownpropertydescriptors.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">Object.getOwnPropertyDescriptors(<var>obj</var>)</pre>
+
+<h3 id="Parâmetro">P<span><span>arâmetro</span></span></h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd><span class="tlid-translation translation" lang="pt"><span title="">O objeto pelo o qual deseja obter todos os descritores de propriedade próprios.</span></span></dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um objeto contendo todas as propriedades descritivas de um objeto. Pode ser um objeto vazio, se não existir propriedade.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Esse método permite examinar a descrição precisa de todas as propriedades de um objeto. Uma propriedade em JavaScript consiste de um nome com valor string ou um {{jsxref("Symbol")}} e uma propriedade descritora. Outras informações sobre propriedade de tipo descritoras e seus atributos podem ser encontradas em {{jsxref("Object.defineProperty()")}}.</p>
+
+<p>Uma propriedade descritora é um registro com alguns dos seguintes atributos:</p>
+
+<dl>
+ <dt><code>value</code></dt>
+ <dd>O valor associdado com à propriedade (somente descritores de dados).</dd>
+ <dt><code><strong>writable</strong></code></dt>
+ <dd><code>true</code> se somente o valor associado com a propriedade pode ser alterada (somente descritores de dados).</dd>
+ <dt><code>get</code></dt>
+ <dd>Uma função que serve como um capturador para a propriedade ou {{jsxref("undefined")}} se não existir um capturador (somente descritores de acesso).</dd>
+ <dt><code>set</code></dt>
+ <dd>Uma função que serve como um configurador para a propriedade, ou {{jsxref("undefined")}} se não existir um configurador (somente descritores de acesso).</dd>
+ <dt><code>configurable</code></dt>
+ <dd><code>true</code> se e somente se o tipo da propriedade descritora pode ser alterada e se a propriedade pode ser deletada do objeto <span><span>correspondente</span></span>.</dd>
+ <dt><code>enumerable</code></dt>
+ <dd><code>true</code> se e somente se essa propriedade se mostrar durante a enumeração da propriedade no objeto <span><span>correspondente</span></span>.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Criando_um_clone_superficial">Criando um clone superficial</h3>
+
+<p>Enquanto o {{jsxref("Object.assign()")}} método vai copiar somente o enumerável e as próprias propriedades da origem de um objeto para o objeto alvo, você é capaz de usar esse método e {{jsxref("Object.create()")}} para uma cópia superficial entre dois objetos desconhecidos:</p>
+
+<pre class="brush: js notranslate">Object.create(
+  Object.getPrototypeOf(obj),
+  Object.getOwnPropertyDescriptors(obj)
+);
+</pre>
+
+<h3 id="Criando_uma_subclasse">Criando uma subclasse</h3>
+
+<p>Um modo típico de criar uma subclasse é definir a subclasse, configurar um <span><span>protótipo para uma instância da superclasse e depois difinir as propriedades daquela instância. Isso pode ficar estranho especialmente para os capturadores e configuradores. Ao invés disso, você pode usar esse código para configurar o protótipo </span></span>:</p>
+
+<pre class="brush: js notranslate">function superclass() {}
+superclass.prototype = {
+  // Define seu método e propriedades aqui
+};
+function subclass() {}
+subclass.prototype = Object.create(
+  superclass.prototype,
+  {
+    // Define seu método e propriedades aqui
+  }
+);
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.getownpropertydescriptors', 'Object.getOwnPropertyDescriptors')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibiliadde_de_navegadores">Compatibiliadde de navegadores</h2>
+
+<div>
+<div class="hidden">A tablea de compatibilidade dessa página é gerada de dados estruturados. Se você gostaria de contribuir com os dados, por favor dê uma olhada em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e <span class="text">mande-nos</span> uma pull request.</div>
+
+<p>{{Compat("javascript.builtins.Object.getOwnPropertyDescriptors")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.getOwnPropertyDescriptor()")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+ <li><a href="https://github.com/tc39/proposal-object-getownpropertydescriptors">Polyfill</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.html
new file mode 100644
index 0000000000..1843ce8d21
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertynames/index.html
@@ -0,0 +1,211 @@
+---
+title: Object.getOwnPropertyNames()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames
+tags:
+  - Objeto
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertyNames
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Object.getOwnPropertyNames()</code></strong> retorna um vetor com todas as propriedades (enumeráveis ou não) encontradas diretamente em um dado objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Object.getOwnPropertyNames(<var>obj</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto, cujas suas próprias propriedades, enumeráveis ou não, serão retornadas.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.getOwnPropertyNames()</code> retorna um vetor cujos elementos são strings correspondentes as propriedades enumeráveis ou não, encontradas em <code>obj</code>. A ordem das propriedades enumeráveis no vetor é consistente com a ordenação exposta por um laço  {{jsxref("Statements/for...in", "for...in")}} (ou por {{jsxref("Object.keys()")}}) nas propriedades do objeto. A ordenação das propriedades não-enumeráveis no vetor, e entre as propriedades enumeráveis, não está definida.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Object.getOwnPropertyNames()">Usando <code>Object.getOwnPropertyNames()</code></h3>
+
+<pre class="brush: js">var arr = ['a', 'b', 'c'];
+console.log(Object.getOwnPropertyNames(arr).sort());
+// logs ["0", "1", "2", "length"]
+
+// Array-like object
+var obj = { 0: 'a', 1: 'b', 2: 'c' };
+console.log(Object.getOwnPropertyNames(obj).sort());
+// logs ["0", "1", "2"]
+
+// Logging property names and values using Array.forEach
+Object.getOwnPropertyNames(obj).forEach(function(val, idx, array) {
+  console.log(val + ' -&gt; ' + obj[val]);
+});
+// logs
+// 0 -&gt; a
+// 1 -&gt; b
+// 2 -&gt; c
+
+// non-enumerable property
+var my_obj = Object.create({}, {
+  getFoo: {
+    value: function() { return this.foo; },
+    enumerable: false
+  }
+});
+my_obj.foo = 1;
+
+console.log(Object.getOwnPropertyNames(my_obj).sort());
+// logs ["foo", "getFoo"]
+</pre>
+
+<p>Se voce quer somente as propriedades enumeráveis, veja {{jsxref("Object.keys()")}} ou use um laço {{jsxref("Statements/for...in", "for...in")}} (contudo, note que isto irá retornar propriedades enumeráveis não encontradas diretamente naquele objeto, mas também junto com a cadeia prototype do objeto a menos que o último seja filtrado com {{jsxref("Object.prototype.hasOwnProperty()", "hasOwnProperty()")}}).</p>
+
+<p>Ítens na cadeia prototype não são listados:</p>
+
+<pre class="brush: js">function ParentClass() {}
+ParentClass.prototype.inheritedMethod = function() {};
+
+function ChildClass() {
+  this.prop = 5;
+  this.method = function() {};
+}
+ChildClass.prototype = new ParentClass;
+ChildClass.prototype.prototypeMethod = function() {};
+
+console.log(
+  Object.getOwnPropertyNames(
+    new ChildClass() // ["prop", "method"]
+  )
+);
+</pre>
+
+<h3 id="Obtenha_somente_não-enumeráveis">Obtenha somente não-enumeráveis</h3>
+
+<p>Isto usa a função {{jsxref("Array.prototype.filter()")}} para remover as chaves enumeráveis (obtidas com {{jsxref("Object.keys()")}}) de uma lista com todas as chaves (obtidas com <code>Object.getOwnPropertyNames()</code>) deixando somente as chaves não-enumeráveis.</p>
+
+<pre class="brush: js">var target = myObject;
+var enum_and_nonenum = Object.getOwnPropertyNames(target);
+var enum_only = Object.keys(target);
+var nonenum_only = enum_and_nonenum.filter(function(key) {
+  var indexInEnum = enum_only.indexOf(key);
+  if (indexInEnum == -1) {
+    // not found in enum_only keys mean the key is non-enumerable,
+    // so return true so we keep this in the filter
+    return true;
+  } else {
+    return false;
+  }
+});
+
+console.log(nonenum_only);
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento desse método não é um objeto (um tipo primitivo), então isso causará um {{jsxref("TypeError")}}. No ES6, um argumento diferente de objeto será transformado em um objeto.</p>
+
+<pre class="brush: js">Object.getOwnPropertyNames('foo');
+// TypeError: "foo" is not an object (ES5 code)
+
+Object.getOwnPropertyNames('foo');
+// ["0", "1", "2", "length"]  (ES6 code)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Esperificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.4', 'Object.getOwnPropertyNames')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>
+    <p>Definição inicial. Implementado no JavaScript 1.8.5.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.getownpropertynames', 'Object.getOwnPropertyNames')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.getownpropertynames', 'Object.getOwnPropertyNames')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_navegadores">Compatibilidade em navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_específicas_para_SpiderMonkey">Notas específicas para SpiderMonkey</h2>
+
+<p>Antes do SpiderMonkey 28 {{geckoRelease("28")}}, <code>Object.getOwnPropertyNames</code> não via propriedades não resolvidas de objetos {{jsxref("Error")}}. Isto foi resolvido em versões posteriores ({{bug("724768")}}).</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerabilidade e posse de propriedades</a></li>
+ <li>{{jsxref("Object.prototype.hasOwnProperty()")}}</li>
+ <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Array.forEach()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html
new file mode 100644
index 0000000000..319253b313
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getownpropertysymbols/index.html
@@ -0,0 +1,79 @@
+---
+title: Object.getOwnPropertySymbols()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getOwnPropertySymbols
+---
+<div>{{JSRef}}</div>
+
+<p>O <code><strong>Object.getOwnPropertySymbols()</strong></code> método retorna uma array com todas propriedades de símbolo encontradas diretamente em um determinado objeto dado.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-getownpropertysymbols.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush: js notranslate"><code>Object.getOwnPropertySymbols(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetro"><span><span>Parâmetro</span></span></h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto pelo qual as propriedades de símbolos são retornas.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma array com todas as propriedades de símbolos encontradas diretamente pelo o objeto dado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Similar do {{jsxref("Object.getOwnPropertyNames()")}}, você pode obter todas as propriedades de símbolo de um objeto dado como um array de símbolos. Lembre que o próprio {{jsxref("Object.getOwnPropertyNames()")}} não contém as propriedades de símbolo de um objeto e somente as propriedades de string.</p>
+
+<p>Como todos os objetos não possuem símbolos próprios inicialmente, o <code>Object.getOwnPropertySymbols()</code> retorna uma array vazia a menos que você tenha definido as propriedades de símbolo do seu objeto .</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_getOwnPropertySymbols">Usando getOwnPropertySymbols</h3>
+
+<pre class="brush: js notranslate">var obj = {};
+var a = Symbol('a');
+var b = Symbol.for('b');
+
+obj[a] = 'localSymbol';
+obj[b] = 'globalSymbol';
+
+var objectSymbols = Object.getOwnPropertySymbols(obj);
+
+console.log(objectSymbols.length); // retorno esperado 2
+console.log(objectSymbols);        // retorno esperado (2) [Symbol(a), Symbol(b)]
+console.log(objectSymbols[0]);     // retorno esperado Symbol(a)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.getownpropertysymbols', 'Object.getOwnPropertySymbols')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+<div class="hidden">A tablea de compatibilidade dessa página é gerada de dados estruturados. Se você gostaria de contribuir com os dados, por favor dê uma olhada em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e <span class="text">mande-nos</span> uma pull request.</div>
+
+<p>{{Compat("javascript.builtins.Object.getOwnPropertySymbols")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+ <li>{{jsxref("Symbol")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.html b/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.html
new file mode 100644
index 0000000000..a1e3bf1910
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/getprototypeof/index.html
@@ -0,0 +1,124 @@
+---
+title: Object.getPrototypeOf()
+slug: Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/getPrototypeOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.getPrototypeOf()</strong></code> retorna o prototype (isto é, o valor da propriedade interna <code>[[Prototype]]</code>) do objeto especificado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.getPrototypeOf(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto cujo prototype será retornado.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var proto = {};
+var obj = Object.create(proto);
+Object.getPrototypeOf(obj) === proto; // true
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5 será lançada uma exceção {{jsxref("TypeError")}} se o parâmetro obj não for um objeto. No ES6, no entanto, esse valor será submetido a um {{jsxref("Object")}} equivalente ao seu tipo e retornado.</p>
+
+<pre class="brush: js">Object.getPrototypeOf("foo");
+// TypeError: "foo" não é um objeto (código ES5)
+Object.getPrototypeOf("foo");
+// String.prototype                  (código ES6)
+</pre>
+
+<h2 id="Especificação">Especificação</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('ES5.1', '#sec-15.2.3.2', 'Object.getPrototypeOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.getprototypeof', 'Object.getProtoypeOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("1.9.1")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12.10")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_específicas_para_o_Opera">Notas específicas para o Opera</h2>
+
+<p>Embora as versões mais antigas do Opera não suportem <code>Object.getPrototypeOf()</code>, ele suporta a propriedade não oficial {{jsxref("Object.proto", "__proto__")}} desde de a sua versão 10.50.</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.setPrototypeOf()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Object.prototype.__proto__")}}</li>
+ <li>John Resig's post on <a class="external" href="http://ejohn.org/blog/objectgetprototypeof/">getPrototypeOf</a></li>
+ <li>{{jsxref("Reflect.getPrototypeOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.html b/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.html
new file mode 100644
index 0000000000..aef0554b86
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/hasownproperty/index.html
@@ -0,0 +1,193 @@
+---
+title: Object.prototype.hasOwnProperty()
+slug: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
+---
+<div>{{JSRef("Global_Objects", "Object")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <code><strong>hasOwnProperty()</strong></code> retorna um booleano indicando se o objeto possui a propriedade especificada como uma propriedade definida no próprio objeto em questão (ao contrário de uma propriedade herdada).</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>obj</em>.hasOwnProperty(<em>prop</em>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Uma {{jsxref("String")}} ou <a href="https://developer.mozilla.org/pt-BR/docs/Glossary/Symbol">symbol</a> indicando o nome da propriedade a ser verificada.</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>Um {{jsxref("Boolean", "booleano")}} indicando se o objeto possui ou não a propriedade especificada como uma propriedade do próprio objeto e que a propriedade não é uma propriedade herdada.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Todo objeto descendente de <code>Object</code> herda o método <code>hasOwnProperty</code>. Este método pode ser usado para determinar se um objeto possui a propriedade especificada como propriedade direta do objeto.</p>
+
+<p>Diferentemente do operador {{jsxref("Operators/in", "in")}}, este método não checa a cadeia prototípica do objeto.</p>
+
+<h2 id="Examples" name="Examples">Nota</h2>
+
+<p>o método <code>hasOwnProperty</code> retorna <code>true</code> mesmo se o valor da propridade em questão é <code>null</code> ou <code>undefined</code></p>
+
+<pre class="syntaxbox"><code>o = new Object();
+o.propUm = null;
+o.hasOwnProperty('propUm'); // retorna true
+o.propDois = undefined;
+o.hasOwnProperty('propDois'); // retorna true</code>
+</pre>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Using_hasOwnProperty_to_test_for_a_property.27s_existence" name="Example:_Using_hasOwnProperty_to_test_for_a_property.27s_existence">Usando <code>hasOwnProperty</code> para testar a existência de uma propriedade</h3>
+
+<p>O seguinte exemplo determina se o objeto <code>o</code> possui uma propriedade com o nome <code>prop</code>:</p>
+
+<pre><code>o = new Object();
+o.hasOwnProperty('prop'); // retorna false
+o.prop = 'existe';
+o.hasOwnProperty('prop'); // retorna true</code></pre>
+
+<h3 id="Example_Direct_versus_inherited_properties" name="Example:_Direct_versus_inherited_properties">Propriedades Diretas vs Propriedades Herdadas</h3>
+
+<p>O seguinte exemplo diferencia entre propriedade diretas e propriedade herdadas da cadeia prototípica:</p>
+
+<pre class="brush: js">o = new Object();
+o.prop = 'existe';
+o.hasOwnProperty('prop');             // Retorna true
+o.hasOwnProperty('toString');         // Retorna false
+o.hasOwnProperty('hasOwnProperty');   // Retorna false</pre>
+
+<h3 id="Example_Itarate_over_properties_not_considering_inherited_properties" name="Example:_Itarate_over_properties_not_considering_inherited_properties">Percorrer através das propriedades de um objeto</h3>
+
+<p class="syntaxbox">O seguinte exemplo mostra como percorrer as propriedade de um objeto sem executar as propriedade herdadas.</p>
+
+<p class="syntaxbox">Vale observar que o loop {{jsxref("Statements/for...in", "for...in")}} percorre somente itens enumeráveis. Entretanto, o método hasOwnProperty também funciona com propriedades não enumeráveis.</p>
+
+<pre class="brush: js">var buz = {
+    fog: 'stack'
+};
+
+for (var nome in buz) {
+    if (buz.hasOwnProperty(nome)) {
+        alert("this is fog (" + nome + ") for sure. Value: " + buz[nome]);
+    }
+    else {
+        alert(nome); // toString ou qualquer outra coisa
+    }
+}</pre>
+
+<h3 id="Exemplo_hasOwnProperty_como_propriedade">Exemplo: <code>hasOwnProperty</code> como propriedade</h3>
+
+<p>JavaScript não protege o nome <code>hasOwnProperty</code>, assim, se existir a possibilidade do objeto possuir uma propriedade com esse nome, é necessário usar<code> <em>externamente </em>hasOwnProperty</code> para se ter o resultado correto:</p>
+
+<pre class="brush: js">var foo = {
+    hasOwnProperty: function() {
+        return false;
+    },
+    bar: 'Here be dragons'
+};
+
+foo.hasOwnProperty('bar'); // Sempre retorna false
+
+// Usando a propriedade hasOwnProperty de outro objeto e definindo 'this' como foo
+({}).hasOwnProperty.call(foo, 'bar'); // true
+
+// Também é possível usar hasOwnProperty do objeto
+Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
+</pre>
+
+<p>Observe que neste ultimo caso nenhum novo objeto é criado.</p>
+
+<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>ECMAScript 3rd Edition. Implemented in JavaScript 1.5</td>
+   <td>Standard</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.5', 'Object.prototype.hasOwnProperty')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_Also" name="See_Also">Veja Também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties" title="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></li>
+ <li>{{jsxref("Operators/in", "in")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_Revisited">JavaScript Guide: Inheritance revisted</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/index.html b/files/pt-br/web/javascript/reference/global_objects/object/index.html
new file mode 100644
index 0000000000..eb891fea08
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/index.html
@@ -0,0 +1,180 @@
+---
+title: Object
+slug: Web/JavaScript/Reference/Global_Objects/Object
+tags:
+  - Objeto
+translation_of: Web/JavaScript/Reference/Global_Objects/Object
+---
+<div>{{JSRef}}</div>
+
+<p>O construtor <code>Object</code> cria um wrapper de objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">// Object initialiser or literal
+{ [ <var>nameValuePair1</var>[, <var>nameValuePair2</var>[, ...<var>nameValuePairN</var>] ] ] }
+
+// Called as a constructor
+new Object([<var>value</var>])</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>nameValuePair1, nameValuePair2, ... nameValuePair<em>N</em></code></dt>
+ <dd>Pares de nomes (strings) e valores (qualquer valor) em que o nome é separado do valor por dois pontos.</dd>
+ <dt><code>value</code></dt>
+ <dd>Qualquer valor.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O construtor <code>Object</code> cria um wrapper de objeto para o valor fornecido. Se o valor for {{jsxref ("null")}} ou {{jsxref ("undefined")}}, ele criará e retornará um objeto vazio, caso contrário, retornará um objeto de um Type que corresponde ao dado valor. Se o valor já for um objeto, ele retornará o valor.</p>
+
+<p>Quando chamado em um contexto não-construtor, o <code>object</code> se comporta de forma idêntica ao <code>new Object ()</code>.</p>
+
+<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">object initializer / literal syntax</a>.</p>
+
+<h2 id="Propriedades_do_construtor_Object">Propriedades do construtor <code>Object</code></h2>
+
+<dl>
+ <dt><code>Object.length</code></dt>
+ <dd>Tem um valor de 1.</dd>
+ <dt>{{jsxref("Object.prototype")}}</dt>
+ <dd>Permite a adição de propriedades a todos os objetos do tipo Object.</dd>
+</dl>
+
+<h2 id="Métodos_do_construtor_Object">Métodos do construtor <code>Object</code></h2>
+
+<dl>
+ <dt>{{jsxref("Object.assign()")}}</dt>
+ <dd>Copia os valores de todas as propriedades próprias enumeráveis ​​de um ou mais objetos de origem para um objeto de destino.</dd>
+ <dt>{{jsxref("Object.create()")}}</dt>
+ <dd>Cria um novo objeto com o objeto e as propriedades do protótipo especificado.</dd>
+ <dt>{{jsxref("Object.defineProperty()")}}</dt>
+ <dd>Adiciona a propriedade nomeada descrita por um determinado descritor a um objeto.</dd>
+ <dt>{{jsxref("Object.defineProperties()")}}</dt>
+ <dd>Adiciona as propriedades nomeadas descritas pelos descritores fornecidos a um objeto.</dd>
+ <dt>{{jsxref("Object.entries()")}}</dt>
+ <dd>Retorna uma matriz contendo todos os pares <code>[key, value]</code> das próprias propriedades de string enumeráveis ​​de um determinado objeto.</dd>
+ <dt>{{jsxref("Object.freeze()")}}</dt>
+ <dd>Congela um objeto: outro código não pode excluir ou alterar nenhuma propriedade.</dd>
+ <dt>{{jsxref("Object.fromEntries()")}}</dt>
+ <dd>Retorna um novo objeto de um iterável de pares de valor-chave (reverso à {{jsxref("Object.entries")}}).</dd>
+ <dt>{{jsxref("Object.getOwnPropertyDescriptor()")}}</dt>
+ <dd>Retorna um descritor de propriedade para uma propriedade nomeada em um objeto.</dd>
+ <dt>{{jsxref("Object.getOwnPropertyDescriptors()")}}</dt>
+ <dd>Retorna um objeto contendo todos os descritores de propriedade para um objeto.</dd>
+ <dt>{{jsxref("Object.getOwnPropertyNames()")}}</dt>
+ <dd>Retorna uma matriz contendo os nomes de todas as propriedades enumeráveis ​​e não enumeráveis ​​do próprio objeto fornecido.</dd>
+ <dt>{{jsxref("Object.getOwnPropertySymbols()")}}</dt>
+ <dd>Retorna uma matriz de todas as propriedades de símbolo encontradas diretamente sobre um determinado objeto.</dd>
+ <dt>{{jsxref("Object.getPrototypeOf()")}}</dt>
+ <dd>Retorna o protótipo do objeto especificado.</dd>
+ <dt>{{jsxref("Object.is()")}}</dt>
+ <dd>Compara se dois valores são o mesmo valor. Equivale a todos os valores de <code>NaN</code> (que diferem da Comparação de Igualdade Abstrata e da Comparação de Igualdade Estrita).</dd>
+ <dt>{{jsxref("Object.isExtensible()")}}</dt>
+ <dd>Determina se a extensão de um objeto é permitida.</dd>
+ <dt>{{jsxref("Object.isFrozen()")}}</dt>
+ <dd>Determina se um objeto foi congelado.</dd>
+ <dt>{{jsxref("Object.isSealed()")}}</dt>
+ <dd>Determina se um objeto está selado.</dd>
+ <dt>{{jsxref("Object.keys()")}}</dt>
+ <dd>Retorna uma matriz contendo os nomes de todas as propriedades de string enumeráveis ​​do objeto fornecido.</dd>
+ <dt>{{jsxref("Object.preventExtensions()")}}</dt>
+ <dd>Impede qualquer extensão de um objeto.</dd>
+ <dt>{{jsxref("Object.seal()")}}</dt>
+ <dd>Impede que outro código exclua propriedades de um objeto.</dd>
+ <dt>{{jsxref("Object.setPrototypeOf()")}}</dt>
+ <dd>Define o protótipo (isto é, a propriedade interna <code>[[Prototype]]</code>).</dd>
+ <dt>{{jsxref("Object.values()")}}</dt>
+ <dd>Retorna uma matriz contendo os valores que correspondem a todas as propriedades de string enumeráveis ​​do próprio objeto.</dd>
+</dl>
+
+<h2 id="Instâncias_de_Object_e_Object_de_protótipo_de_objeto">Instâncias de <code>Object</code> e <code>Object</code> de protótipo de objeto</h2>
+
+<p>Todos os objetos em JavaScript são descendentes do <code>Object</code>; todos os objetos herdam métodos e propriedades de {{jsxref("Object.prototype")}}, embora eles possam ser substituídos. Por exemplo, protótipos de outros construtores substituem a propriedade <code>constructor</code> e fornecer seus próprios métodos <code>toString()</code>. As alterações no objeto de protótipo <code>Object</code> são propagadas para todos os objetos, a menos que as propriedades e os métodos sujeitos a essas alterações sejam substituídos na cadeia de protótipos.</p>
+
+<h3 id="Propriedades_(enUS)">Propriedades (enUS)</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Properties')}}</div>
+
+<h3 id="Métodos_(enUS)">Métodos (enUS)</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Methods')}}</div>
+
+<h2 id="Excluindo_uma_propriedade_de_um_objeto">Excluindo uma propriedade de um objeto</h2>
+
+<p>Não há nenhum método em um Objeto para excluir suas próprias propriedades (por exemplo, como <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Map/delete" style="">Map.prototype.delete()</a></code>). Para isso, é necessário usar o operador delete.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Object_com_tipos_undefined_e_null">Usando <code>Object</code> com tipos <code>undefined</code> e <code>null</code></h3>
+
+<p>Os exemplos a seguir armazenam um <code>Object</code> vazio na variável "<code>o</code>":</p>
+
+<pre class="brush: js">var o = new Object();
+</pre>
+
+<pre class="brush: js">var o = new Object(undefined);
+</pre>
+
+<pre class="brush: js">var o = new Object(null);
+</pre>
+
+<h3 id="Using_Object_to_create_Boolean_objects">Using <code>Object</code> to create <code>Boolean</code> objects</h3>
+
+<p>Os exemplos a seguir armazenam objetos {{jsxref("Boolean")}} na variável "<code>o</code>":</p>
+
+<pre class="brush: js">// equivalent to o = new Boolean(true);
+var o = new Object(true);
+</pre>
+
+<pre class="brush: js">// equivalent to o = new Boolean(false);
+var o = new Object(Boolean());
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2', 'Object')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>------------------------------------------------</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object-objects', 'Object')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Adicionado <code>Object.assign</code>, <code>Object.getOwnPropertySymbols</code>, <code>Object.setPrototypeOf</code> e <code>Object.is</code></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object-objects', 'Object')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Adicionado  <code>Object.entries</code>, <code>Object.values</code> e <code>Object.getOwnPropertyDescriptors</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Object initializer</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/is/index.html b/files/pt-br/web/javascript/reference/global_objects/object/is/index.html
new file mode 100644
index 0000000000..ff3131de50
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/is/index.html
@@ -0,0 +1,177 @@
+---
+title: Object.is()
+slug: Web/JavaScript/Reference/Global_Objects/Object/is
+tags:
+  - Comparação
+  - Condição
+  - ECMAScript6
+  - Igualdade
+  - JavaScript
+  - Objeto
+  - condicional
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/is
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.is()</strong></code> determina se dois valores correspondem <a href="/pt-BR/docs/Web/JavaScript/Equality_comparisons_and_sameness">ao mesmo valor</a>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.is(<var>value1</var>, <var>value2</var>);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>value1</code></dt>
+ <dd>O primeiro valor a ser comparado.</dd>
+ <dt><code>value2</code></dt>
+ <dd>O segundo valor a ser comparado.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se os dois argumentos possuem o mesmo valor ou não.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.is()</code> determina se dois valores correspondem <a href="/pt-BR/docs/Web/JavaScript/Equality_comparisons_and_sameness">ao mesmo valor</a>. Dois valores correspondem ao mesmo valor se uma das seguintes condições for verdadeira:</p>
+
+<ul>
+ <li>ambos são {{jsxref("undefined")}}</li>
+ <li>ambos são {{jsxref("null")}}</li>
+ <li>ambos são <code>true</code> ou ambos são <code>false</code></li>
+ <li>ambos são strings do mesmo comprimento, com os mesmos caracteres</li>
+ <li>ambos são o mesmo objeto</li>
+ <li>ambos são numéricos e
+  <ul>
+   <li>ambos são <code>+0</code></li>
+   <li>ambos são <code>-0</code></li>
+   <li>ambos são {{jsxref("NaN")}}</li>
+   <li>ou ambos são não-zero e ambos são não {{jsxref("NaN")}} e ambos correspondem ao mesmo valor</li>
+  </ul>
+ </li>
+</ul>
+
+<p>Isso <em>não é </em>o mesmo que ser igual de acordo com o operador {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}. O operador {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} aplica diversas coerções para ambos os lados (se eles não correspondem ao mesmo Tipo) antes de testar a igualdade (resultando em comportamentos como a comparação <code>"" == false </code>retornar <code>true</code>), enquanto <code>Object.is</code> não realiza a coerção de nenhum dos valores.</p>
+
+<p>Isso também <em>não</em> <em>é</em> o mesmo que ser igual de acordo com o operador {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}. O operador {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}} (assim como o operador {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}) trata os valores numéricos <code>-0</code> e <code>+0</code> como iguais e trata {{jsxref("Number.NaN")}} como não igual a {{jsxref("NaN")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">Object.is('foo', 'foo');     // true
+Object.is(window, window);   // true
+
+Object.is('foo', 'bar');     // false
+Object.is([], []);           // false
+
+var test = { a: 1 };
+Object.is(test, test);       // true
+
+Object.is(null, null);       // true
+
+// Casos especiais
+Object.is(0, -0);            // false
+Object.is(-0, -0);           // true
+Object.is(NaN, 0/0);         // true
+</pre>
+
+<h2 id="Polyfill_para_navegadores_que_não_suportam_ES6">Polyfill para navegadores que não suportam ES6</h2>
+
+<p><code>Object.is()</code> é uma adição proposta ao padrão ECMA-262; e como tal, pode não estar presente em todos os navegadores. Você pode contornar essa situação por meio da adição do seguinte código no começo de seus scripts. Isso permitirá a você utilizar <code>Object.is()</code>, mesmo quando não houver suporte por parte do navegador.</p>
+
+<pre class="brush: js">if (!Object.is) {
+  Object.is = function(x, y) {
+    // Algoritmo para verificar se os valores sao iguais
+    if (x === y) { // Passos 1-5, 7-10
+      // Passos 6.b-6.e: +0 != -0
+      return x !== 0 || 1 / x === 1 / y;
+    } else {
+      // Passo 6.a: NaN == NaN
+      return x !== x &amp;&amp; y !== y;
+    }
+  };
+}
+</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-object.is', 'Object.is')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.is', 'Object.is')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegador">Compatibilidade com navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("30")}}</td>
+   <td>{{CompatGeckoDesktop("22")}}</td>
+   <td>
+    <p>{{CompatNo}}</p>
+   </td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("22")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Equality_comparisons_and_sameness">Comparações de igualdade</a> — uma comparação dos três recursos implementados para verificação de igualdade.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.html b/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.html
new file mode 100644
index 0000000000..7ef9f5f97c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/isextensible/index.html
@@ -0,0 +1,107 @@
+---
+title: Object.isExtensible()
+slug: Web/JavaScript/Reference/Global_Objects/Object/isExtensible
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/isExtensible
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>Object.isExtensible()</code></strong> verifica se um objeto pode ser extendido (se é ou não possível adicinar novas propriedades).</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-isextensible.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.isExtensible(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto a ser verificado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um valor booleano ({{jsxref("Boolean")}}) que indica se o objeto pode ser extendido.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Objetos são extensíveis por padrão: novas propriedades podem ser adicionadas, e (em ambientes que suportam {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}}) a propriedade __proto__ pode ser modificada. Um objeto pode ser marcado como não extensível usando {{jsxref("Object.preventExtensions()")}}, {{jsxref("Object.seal()")}}, ou {{jsxref("Object.freeze()")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">// Novos objetos podem ser extendidos.
+var empty = {};
+Object.isExtensible(empty); // === true
+
+// ...mas isso pode mudar.
+Object.preventExtensions(empty);
+Object.isExtensible(empty); // === false
+
+// Objetos selados, não podem ser extendidos.
+var sealed = Object.seal({});
+Object.isExtensible(sealed); // === false
+
+// Objetos congelados também não podem ser extendidos.
+var frozen = Object.freeze({});
+Object.isExtensible(frozen); // === false
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento fornecido não for um objeto (um tipo primitivo), isso vai causar um erro do tipo {{jsxref("TypeError")}}. No ES2015, um argumento que não é um objeto será tratado como um objeto não extensível, simplesmente retornando <code>false</code>.</p>
+
+<pre class="brush: js">Object.isExtensible(1);
+// TypeError: 1 is not an object (ES5 code)
+
+Object.isExtensible(1);
+// false                         (ES2015 code)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.13', 'Object.isExtensible')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.isextensible', 'Object.isExtensible')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.isextensible', 'Object.isExtensible')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.isExtensible")}}</p>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+ <li>{{jsxref("Reflect.isExtensible()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.html b/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.html
new file mode 100644
index 0000000000..1cab1b4843
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/isfrozen/index.html
@@ -0,0 +1,172 @@
+---
+title: Object.isFrozen()
+slug: Web/JavaScript/Reference/Global_Objects/Object/isFrozen
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/isFrozen
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.isFrozen()</strong></code> determina se um objeto está {{jsxref("Object.freeze()", "frozen", "", 1)}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-isfrozen.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.isFrozen(<var>obj</var>)</code></pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto que será verificado.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Um valor {{jsxref("Boolean")}} indicando se o objeto está frozen.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Um objeto estará frozen se, e apenas se, ele não for {{jsxref("Object.isExtensible()", "extensible", "", 1)}}, todas as suas propriedades não são configuráveis e todas suas propriedades de dados (propriedades que não são asessores de propriedades com getters ou setters) não podem ser modificadas.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<pre class="brush: js">// Um novo objeto é extensível, então ele não está frozen.
+Object.isFrozen({}); // === false
+
+// Um objeto vazio que não é extensível
+// é vagamente frozen.
+var vacuouslyFrozen = Object.preventExtensions({});
+Object.isFrozen(vacuouslyFrozen); // === true
+
+// Um novo objeto com uma propriedade também é extensível,
+// portanto não está frozen.
+var oneProp = { p: 42 };
+Object.isFrozen(oneProp); // === false
+
+// Impedir extensões do objeto ainda
+// não o torna frozen, pois a propriedade ainda será
+// configurável (e modificável).
+Object.preventExtensions(oneProp);
+Object.isFrozen(oneProp); // === false
+
+// ...Porém, deletando a propriedade o objeto se tornará
+// vagamente frozen.
+delete oneProp.p;
+Object.isFrozen(oneProp); // === true
+
+// Um objeto não extensível e não modificável,
+// mas com uma propriedade configurável não será frozen.
+var nonWritable = { e: 'plep' };
+Object.preventExtensions(nonWritable);
+Object.defineProperty(nonWritable, 'e', {
+  writable: false
+}); // tornar não modificável
+Object.isFrozen(nonWritable); // === false
+
+// Alterando a propriedade para não configurável
+// tornará o objeto frozen.
+Object.defineProperty(nonWritable, 'e', {
+  configurable: false
+}); // make non-configurable
+Object.isFrozen(nonWritable); // === true
+
+// Um objeto não extensível com uma propriedade não configurável
+// mas modificável não será frozen.
+var nonConfigurable = { release: 'the kraken!' };
+Object.preventExtensions(nonConfigurable);
+Object.defineProperty(nonConfigurable, 'release', {
+  configurable: false
+});
+Object.isFrozen(nonConfigurable); // === false
+
+// Alterando a propriedade para não modificável
+// tornará o objeto frozen.
+Object.defineProperty(nonConfigurable, 'release', {
+  writable: false
+});
+Object.isFrozen(nonConfigurable); // === true
+
+// Um objeto não extensível com um assessor de propriedade
+// configurável não será frozen.
+var accessor = { get food() { return 'yum'; } };
+Object.preventExtensions(accessor);
+Object.isFrozen(accessor); // === false
+
+// ...Mas alterando essa propriedade para não configurável
+// o objeto se tornará frozen.
+Object.defineProperty(accessor, 'food', {
+  configurable: false
+});
+Object.isFrozen(accessor); // === true
+
+// A forma mais fácil para um objeto ser frozen
+// é se o método Object.freeze foi usado nele.
+var frozen = { 1: 81 };
+Object.isFrozen(frozen); // === false
+Object.freeze(frozen);
+Object.isFrozen(frozen); // === true
+
+// Por definição, um objeto frozen não é extensível.
+Object.isExtensible(frozen); // === false
+
+// Também por definição, um objeto frozen estará sealed.
+Object.isSealed(frozen); // === true
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento deste método não for um objeot (uma primitiva), ele irá lançar um {{jsxref("TypeError")}}. No ES2015, um argumento que não é objeto será sempre tratado como se fosse um objeto frozen, simplesmente retornando <code>true</code>.</p>
+
+<pre class="brush: js">Object.isFrozen(1);
+// TypeError: 1 is not an object (ES5 code)
+
+Object.isFrozen(1);
+// true                          (ES2015 code)
+</pre>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES5.1', '#sec-15.2.3.12', 'Object.isFrozen')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.isfrozen', 'Object.isFrozen')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.isfrozen', 'Object.isFrozen')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.isFrozen")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.html b/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.html
new file mode 100644
index 0000000000..07ff5404a3
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/isprototypeof/index.html
@@ -0,0 +1,124 @@
+---
+title: Object.prototype.isPrototypeOf()
+slug: Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf
+tags:
+  - Objeto
+  - Prototipo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/isPrototypeOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>isPrototypeOf()</strong></code> checa se um objeto existe em na cadeia de protótipos de um outro objeto.</p>
+
+<div class="note">
+<p><code>isPrototypeOf()</code> difere do operador {{jsxref("Operators/instanceof", "instanceof")}}. Na expressão "<code>objeto instanceof UmaFuncaoQualquer</code>", a cadeia de protótipos do <code>objeto</code> é comparada com <code>UmaFuncaoQualquer.prototype</code>, e não com a própria função <code>UmaFuncaoQualquer</code>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>prototypeObj</var>.isPrototypeOf(<var>objeto</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>objeto</code></dt>
+ <dd>Objeto no qual será feito uma busca na cadeia de protótipos.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se prototypeObj está na cadeia de protótipos do objeto.</p>
+
+<h3 id="Erros_possíveis">Erros possíveis</h3>
+
+<dl>
+ <dt>{{jsxref("TypeError")}}</dt>
+ <dd>Um {{jsxref("TypeError")}} é mostrado se <code><var>prototypeObj</var></code> é <em>undefined </em>ou <em>null</em>.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>isPrototypeOf()</code> lhe permite checar se um objeto está ou não na cadeia de protótipos (cadeia hieráquica) de um outro objeto.</p>
+
+<p>Em outras palavras, você pode descobrir se um objeto x (já instanciado) é herdeiro de um objeto y.</p>
+
+<p> </p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Este exemplo demonstra que <code>Baz.prototype</code>, <code>Bar.prototype</code>, <code>Foo.prototype</code> e<code>Object.prototype</code> estão na cadeia de protótipos de  <code>baz</code> , ou seja, baz herda atributos de Baz, Bar e Foo:</p>
+
+<pre class="brush: js">function Foo() {}
+function Bar() {}
+function Baz() {}
+
+Bar.prototype = Object.create(Foo.prototype);
+Baz.prototype = Object.create(Bar.prototype);
+
+var baz = new Baz();
+
+console.log(Baz.prototype.isPrototypeOf(baz)); // true
+console.log(Bar.prototype.isPrototypeOf(baz)); // true
+console.log(Foo.prototype.isPrototypeOf(baz)); // true
+console.log(Object.prototype.isPrototypeOf(baz)); // true
+</pre>
+
+<p>O método<code>isPrototypeOf()</code>, junto com o operador {{jsxref("Operators/instanceof", "instanceof")}} vêm a ser útil se você tem um código que só pode funcionar quando estiver lidando com objetos que descendem de uma cadeia de protótipos específicos, por exemplo, para garantir que certos métodos ou propriedades estarão presentes naquele objeto que você precisa. </p>
+
+<p>Por exemplo, checar se o objeto <code>baz</code> descende de <code>Foo.prototype</code>:</p>
+
+<pre class="brush: js">if (Foo.prototype.isPrototypeOf(baz)) {
+  // fazer algo seguramente
+}
+</pre>
+
+<h2 id="Specificações">Specificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.6', 'Object.prototype.isPrototypeOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.isprototypeof', 'Object.prototype.isPrototypeOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.isprototypeof', 'Object.prototype.isPrototypeOf')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_o_Browser">Compatibilidade com o Browser</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade desta página é gerada através de dados estruturados. Se você gostaria de contribuir, por favor veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande um <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Object.isPrototypeOf")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Operators/instanceof", "instanceof")}}</li>
+ <li>{{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>
+  <div>{{jsxref("Object.setPrototypeOf()")}}</div>
+ </li>
+ <li>{{jsxref("Object.prototype.__proto__")}} </li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.html b/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.html
new file mode 100644
index 0000000000..67f42f78bc
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/issealed/index.html
@@ -0,0 +1,134 @@
+---
+title: Object.isSealed()
+slug: Web/JavaScript/Reference/Global_Objects/Object/isSealed
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/isSealed
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.isSealed()</strong></code> determina se um objeto está selado.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-issealed.html")}}</div>
+
+<p class="hidden">O código-fonte deste exemplo interativo está armazenado em um repositório do GitHub. Se deseja contribuir com o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie-nos uma <em>pull request</em>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.isSealed(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto que deverá ser verificado.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se o objeto fornecido está ou não selado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Retorna <code>true</code> se o objeto está selado, senão <code>false</code>. Um objeto está selado se ele for "não {{jsxref("Object.isExtensible", "extensible", "", 1)}}" e se todas as suas propriedades estão como "não configuráveis" e assim sendo "não removíveis" (mas não necessariamente "não escrevíveis").</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">// Objetos não são selados por padrão.
+var empty = {};
+Object.isSealed(empty); // === false
+
+// Se você fizer um objeto não extensível vazio,
+// ele estará vagamente selado.
+Object.preventExtensions(empty);
+Object.isSealed(empty); // === true
+
+// O mesmo não é verdadeiro em um objeto "não vazio",
+// a não ser que todas as suas propriedades sejam "não configuráveis".
+var hasProp = { fee: 'fie foe fum' };
+Object.preventExtensions(hasProp);
+Object.isSealed(hasProp); // === false
+
+// Mas torne-os todos "não configuráveis"
+// e o objeto se tornará selado.
+Object.defineProperty(hasProp, 'fee', {
+  configurable: false
+});
+Object.isSealed(hasProp); // === true
+
+// O jeito mais fácil de selar um objeto, com certeza,
+// é Object.seal.
+var sealed = {};
+Object.seal(sealed);
+Object.isSealed(sealed); // === true
+
+// Um objeto selado é, por definição, não extensível.
+Object.isExtensible(sealed); // === false
+
+// Um objeto selado pode estar congelado,
+// mas não precisa estar.
+Object.isFrozen(sealed); // === true
+// (todas as propriedades também não escrevíveis)
+
+var s2 = Object.seal({ p: 3 });
+Object.isFrozen(s2); // === false
+// ('p' continua "escrevível")
+
+var s3 = Object.seal({ get p() { return 0; } });
+Object.isFrozen(s3); // === true
+// (somente a configurabilidade importa nos assessores de propriedade)
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento para esse método não é um objeto (um primitivo), então ele irá causar um {{jsxref("TypeError")}}. No ES2015, um argumento que não seja objeto irá ser tratado como se fosse um objeto selado qualquer, simplesmente retornando <code>true</code>.</p>
+
+<pre class="brush: js">Object.isSealed(1);
+// TypeError: 1 is not an object (ES5 code)
+
+Object.isSealed(1);
+// true                          (ES2015 code)
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.11', 'Object.isSealed')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.issealed', 'Object.isSealed')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.issealed', 'Object.isSealed')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nesta página é gerado a partir de dados estruturados. Se deseja contribuir com os dados, por favor clone o repositório <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.Object.isSealed")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/keys/index.html b/files/pt-br/web/javascript/reference/global_objects/object/keys/index.html
new file mode 100644
index 0000000000..022fdfb410
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/keys/index.html
@@ -0,0 +1,190 @@
+---
+title: Object.keys()
+slug: Web/JavaScript/Reference/Global_Objects/Object/keys
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/keys
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.keys()</strong></code> retorna um array de propriedades enumeraveis de um determinado objeto, na mesma ordem em que é fornecida por um laço {{jsxref("Statements/for...in", "for...in")}} (a diferença é que um laço for-in  enumera propriedades que estejam na cadeia de protótipos).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.keys(<var>obj</var>)</code></pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto cujas propriedades são enumeráveis.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.keys()</code> retorna um array cujo os  elementos são strings correspondentes para a propriedade enumerável encontrada diretamento sobre o objeto. A ordenação das propriedades é a mesma que a dada pelo loop sobre as propriedades do objeto manualmente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var arr = ['a', 'b', 'c'];
+console.log(Object.keys(arr)); // console: ['0', '1', '2']
+
+// array com objeto
+var obj = { 0: 'a', 1: 'b', 2: 'c' };
+console.log(Object.keys(obj)); // console: ['0', '1', '2']
+
+// array como objeto com ordenação aleatória por chave
+var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
+console.log(Object.keys(an_obj)); // console: ['2', '7', '100']
+
+// getFoo é uma propriedade que não é enumerável
+var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
+my_obj.foo = 1;
+
+console.log(Object.keys(my_obj)); // console: ['foo']
+</pre>
+
+<p>Se você quiser todas as propriedades, mesmo que não enumeráveis, consulte:{{jsxref("Object.getOwnPropertyNames()")}}.</p>
+
+<h2 id="Notas">Notas</h2>
+
+<p>Em ES5, Se o argumento para o método this não é um objeto(um primitivo), em seguida ele irá causar um {{jsxref("TypeError")}}. Em ES2015, um argumento não-objeto será forçado a um objeto.</p>
+
+<pre class="brush: js">Object.keys("foo");
+// TypeError: "foo" is not an object (ES5 code)
+
+Object.keys("foo");
+// ["0", "1", "2"]                   (ES2015 code)
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Para adicionar suporte Object.keys compatíveis em ambientes mais antigos que não têm suporte nativo para isso, copie o seguinte trecho:</p>
+
+<pre class="brush: js">// De https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/keys
+if (!Object.keys) {
+  Object.keys = (function() {
+    'use strict';
+    var hasOwnProperty = Object.prototype.hasOwnProperty,
+        hasDontEnumBug = !({ toString: null }).propertyIsEnumerable('toString'),
+        dontEnums = [
+          'toString',
+          'toLocaleString',
+          'valueOf',
+          'hasOwnProperty',
+          'isPrototypeOf',
+          'propertyIsEnumerable',
+          'constructor'
+        ],
+        dontEnumsLength = dontEnums.length;
+
+    return function(obj) {
+      if (typeof obj !== 'object' &amp;&amp; (typeof obj !== 'function' || obj === null)) {
+        throw new TypeError('Object.keys chamado de non-object');
+      }
+
+      var result = [], prop, i;
+
+      for (prop in obj) {
+        if (hasOwnProperty.call(obj, prop)) {
+          result.push(prop);
+        }
+      }
+
+      if (hasDontEnumBug) {
+        for (i = 0; i &lt; dontEnumsLength; i++) {
+          if (hasOwnProperty.call(obj, dontEnums[i])) {
+            result.push(dontEnums[i]);
+          }
+        }
+      }
+      return result;
+    };
+  }());
+}
+</pre>
+
+<p>Por favor, note que o código acima inclui chaves não-enumeráveis no IE7 (e talvez IE8), ao passar em um objeto a partir de uma janela diferente.</p>
+
+<p>Para um simples Browser Polyfill, veja <a href="http://tokenposts.blogspot.com.au/2012/04/javascript-objectkeys-browser.html">Javascript - Object.keys Browser Compatibility</a>.</p>
+
+<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('ES5.1', '#sec-15.2.3.14', 'Object.keys')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado em  JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-object.keys', 'Object.keys')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibilidade">Browser compatibilidade</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Caracteristica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("5")}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Caracteristica</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/observe/index.html b/files/pt-br/web/javascript/reference/global_objects/object/observe/index.html
new file mode 100644
index 0000000000..c9964127c5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/observe/index.html
@@ -0,0 +1,161 @@
+---
+title: Object.observe()
+slug: Web/JavaScript/Reference/Global_Objects/Object/observe
+tags:
+  - JavaScript
+  - Obsoleto
+  - observe
+translation_of: Archive/Web/JavaScript/Object.observe
+---
+<div>
+<p>{{JSRef}} {{obsolete_header}}</p>
+
+<p>O método <strong><code>Object.observe()</code></strong> era usado para observações de mudanças, de forma assíncronas de um objeto. Ele fornecia um fluxo de mudanças na ordem em que elas ocorriam. Porém, está API foi depreciada e removida dos navegadores. Você pode utilizar o objeto {{jsxref("Proxy")}} como alternativa.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.observe(<var>obj</var>, <var>callback</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto a ser observado.</dd>
+ <dt><code>callback</code></dt>
+ <dd>A função chamada cada vez que as alterações são feitas, com o seguinte argumento:
+ <dl>
+  <dt><code>changes</code></dt>
+  <dd>Um array de objetos onde cada item representa uma mudança. As propriedades destes objetos de mudança são:
+  <ul>
+   <li><strong><code>name</code></strong>: O nome da propriedade que foi alterada.</li>
+   <li><strong><code>object</code></strong>: O objeto alterado depois que a mudança foi feita.</li>
+   <li><strong><code>type</code></strong>: Uma string indicando o tipo de mudança. Pode ser <code>"add"</code>, <code>"update"</code>, ou <code>"delete"</code>.</li>
+   <li><strong><code>oldValue</code></strong>: Apenas para os tipos <code>"update"</code> e <code>"delete"</code>. O valor antes da alteração.</li>
+  </ul>
+  </dd>
+  <dt><code>acceptList</code></dt>
+  <dd>A lista dos tipos de alterações a serem observadas no objeto dado para o retorno de chamada dado. Se omitida, o array <code>["add", "update", "delete", "reconfigure", "setPrototype", "preventExtensions"]</code> será usado.</dd>
+  <dt>
+  <h3 id="Retorno">Retorno</h3>
+
+  <p>O objeto será retornado.</p>
+  </dt>
+ </dl>
+ </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>callback</code> é chamado à cada vez que uma mudança ocorre no <code>obj</code>, com um array contendo todas as mudanças na ordem em que elas ocorreram.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_Registrando_todos_os_três_tipos_diferentes">Exemplo: Registrando todos os três tipos diferentes</h3>
+
+<pre class="brush: js">var obj = {
+  foo: 0,
+  bar: 1
+};
+
+Object.observe(obj, function(changes) {
+  console.log(changes);
+});
+
+obj.baz = 2;
+// [{name: 'baz', object: &lt;obj&gt;, type: 'add'}]
+
+obj.foo = 'hello';
+// [{name: 'foo', object: &lt;obj&gt;, type: 'update', oldValue: 0}]
+
+delete obj.baz;
+// [{name: 'baz', object: &lt;obj&gt;, type: 'delete', oldValue: 2}]
+</pre>
+
+<h3 id="Exemplo_Data_Binding">Exemplo: Data Binding</h3>
+
+<pre class="brush: js">// Um modelo chamado "user"
+var user = {
+  id: 0,
+  name: 'Brendan Eich',
+  title: 'Mr.'
+};
+
+// Criando uma saudação para o user
+function updateGreeting() {
+  user.greeting = 'Olá, ' + user.title + ' ' + user.name + '!';
+}
+updateGreeting();
+
+Object.observe(user, function(changes) {
+  changes.forEach(function(change) {
+    // Sempre que o name e o title mudarem, o updateGreeting será executado
+    if (change.name === 'name' || change.name === 'title') {
+      updateGreeting();
+    }
+  });
+});
+</pre>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<p><a href="https://github.com/arv/ecmascript-object-observe">Strawman proposal for ECMAScript 7</a>.</p>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatChrome("36")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("23")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("36")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("23")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.unobserve()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Array.observe()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.html b/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.html
new file mode 100644
index 0000000000..35446ed876
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/preventextensions/index.html
@@ -0,0 +1,131 @@
+---
+title: Object.preventExtensions()
+slug: Web/JavaScript/Reference/Global_Objects/Object/preventExtensions
+tags:
+  - Objeto
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/preventExtensions
+---
+<div>{{JSRef}}</div>
+
+<p><span id="result_box" lang="pt"><span>O método</span></span> <code><strong>Object.preventExtensions()</strong></code> <span id="result_box" lang="pt"><span> impede que novas propriedades sejam adicionadas a um objeto</span></span> (<span class="short_text" id="result_box" lang="pt"><span>isto é, impede futuras extensões ao objeto</span></span>).</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><code>Object.preventExtensions(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto a tornar-se não-extensível.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um objeto tornado não-extensível.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Um objeto é extensível se novas propriedades puderem der adicionadas ao mesmo. <code>Object.preventExtensions()</code> marca um objeto como não mais extensível, de forma que este nunca terá novas propriedades além daquelas que o objeto tinha quando foi marcado como não-extensível. Note que as propriedades de um objeto não-extensível, em geral, ainda poderão ser <em>apagadas</em>. Tentativas de adicionar novas propriedades a um objeto não-extensível falharão, tanto silenciosamente ou lançando uma exceção {{jsxref("TypeError")}} (mais comumente, mas não exclusivamente, quando em {{jsxref("Functions_and_function_scope/Strict_mode", "strict mode", "", 1)}}).</p>
+
+<p><code>Object.preventExtensions()</code> evita apenas a adição de novas propriedades diretas. Proprieades ainda poderão ser adicionadas ao protótipo do objeto.</p>
+
+<p>É impossível tornar um objeto extensível novamente uma vez que o mesmo tenha se tornado não-extensível.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">// Object.preventExtensions retorna o objeto
+// tornado não-extensível.
+var obj = {};
+var obj2 = Object.preventExtensions(obj);
+obj === obj2; // verdadeiro
+
+// Objetos são extensíveis por padrão...
+var empty = {};
+Object.isExtensible(empty); // === verdadeiro
+
+// ...mas isso pode ser mudado.
+Object.preventExtensions(empty);
+Object.isExtensible(empty); // === falso
+
+// Object.defineProperty lança erro quando adiciona-se
+// uma nova propriedade a um objeto não-extensível.
+var nonExtensible = { removable: true };
+Object.preventExtensions(nonExtensible);
+Object.defineProperty(nonExtensible, 'new', {
+  value: 8675309
+}); // lança um TypeError
+
+// No modo restrito, tentar adicionar novas propriedades a
+// um objeto não-extensível lança um TypeError.
+function fail() {
+  'use strict';
+  // lança um TypeError
+  nonExtensible.newProperty = 'FAIL';
+}
+fail();
+</pre>
+
+<p>O protótipo não-extensível de um objeto é imutável:</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> fixed <span class="operator token">=</span> Object<span class="punctuation token">.</span><span class="function token">preventExtensions</span><span class="punctuation token">(</span><span class="punctuation token">{</span><span class="punctuation token">}</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="comment token">// lança um 'TypeError'.</span>
+fixed<span class="punctuation token">.</span>__proto__ <span class="operator token">=</span> <span class="punctuation token">{</span> oh<span class="punctuation token">:</span> <span class="string token">'hai'</span> <span class="punctuation token">}</span><span class="punctuation token">;</span></code></pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento atribuído a este método não for um objeto (for um primitivo), isso causará um erro de tipo {{jsxref("TypeError")}}. No ES2015, um argumento não-objeto será tratado como se o mesmo fosse um objeto não-extensível comum, simplesmente retornando-o.</p>
+
+<pre class="brush: js">Object.preventExtensions(1);
+// TypeError: 1 não é um objeto (código ES5)
+
+Object.preventExtensions(1);
+// 1                             (código ES2015)
+</pre>
+
+<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>{{SpecName('ES5.1', '#sec-15.2.3.10', 'Object.preventExtensions')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado em JavaScript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.preventextensions', 'Object.preventExtensions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.preventextensions', 'Object.preventExtensions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.preventExtensions")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.seal()")}}</li>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+ <li>{{jsxref("Reflect.preventExtensions()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.html b/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.html
new file mode 100644
index 0000000000..a68117bc0c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/propertyisenumerable/index.html
@@ -0,0 +1,128 @@
+---
+title: Object.prototype.propertyIsEnumerable()
+slug: Web/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/propertyIsEnumerable
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>propertyIsEnumerable()</strong></code> retorna um booleano indicando quando a propriedade especificada é enumerável e é a propriedade do próprio objeto</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-prototype-propertyisenumerable.html", "taller")}}</div>
+
+<p class="hidden">O source deste exemplo interativo é armazenado em um repositório GitHub.Se você deseja contribuir com o projeto de exemplos interativos, vá em:<a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie uma solicitação</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>obj</var>.propertyIsEnumerable(<var>prop</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>O nome da propriedade para teste</dd>
+</dl>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>O {{jsxref("Boolean")}} indicando se a propriedade especificada é enumeravel e é a propriedade do objeto</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Every object has a <code>propertyIsEnumerable</code> method. This method can determine whether the specified property in an object can be enumerated by a {{jsxref("Statements/for...in", "for...in")}} loop, with the exception of properties inherited through the prototype chain. If the object does not have the specified property, this method returns <code>false</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="O_uso_basico_de_propertyIsEnumerable">O uso basico de <code>propertyIsEnumerable</code></h3>
+
+<p>O exemplos a seguir mostram o uso de <code>propertyIsEnumerable</code> em um objeto e um array:</p>
+
+<pre class="brush: js notranslate">var o = {};
+var a = [];
+o.prop = 'is enumerable';
+a[0] = 'is enumerable';
+
+o.propertyIsEnumerable('prop');   // returns true
+a.propertyIsEnumerable(0);        // returns true
+</pre>
+
+<h3 id="Objetos_User-defined_vs._built-in">Objetos User-defined vs. built-in</h3>
+
+<p>Os exemplos a seguir demostram a enumerabilidade da propriedade user-defined vs. built-in :</p>
+
+<pre class="brush: js notranslate">var a = ['is enumerable'];
+
+a.propertyIsEnumerable(0);          // returns true
+a.propertyIsEnumerable('length');   // returns false
+
+Math.propertyIsEnumerable('random');   // returns false
+this.propertyIsEnumerable('Math');     // returns false
+</pre>
+
+<h3 id="Propriedade_Direct_vs._inherited">Propriedade Direct vs. inherited</h3>
+
+<pre class="brush: js notranslate">var a = [];
+a.propertyIsEnumerable('constructor');         // returns false
+
+function firstConstructor() {
+  this.property = 'is not enumerable';
+}
+
+firstConstructor.prototype.firstMethod = function() {};
+
+function secondConstructor() {
+  this.method = function() { return 'is enumerable'; };
+}
+
+secondConstructor.prototype = new firstConstructor;
+secondConstructor.prototype.constructor = secondConstructor;
+
+var o = new secondConstructor();
+o.arbitraryProperty = 'is enumerable';
+
+o.propertyIsEnumerable('arbitraryProperty');   // returns true
+o.propertyIsEnumerable('method');              // returns true
+o.propertyIsEnumerable('property');            // returns false
+
+o.property = 'is enumerable';
+
+o.propertyIsEnumerable('property');            // returns true
+
+// These return false as they are on the prototype which
+// propertyIsEnumerable does not consider (even though the last two
+// are iteratable with for-in)
+o.propertyIsEnumerable('prototype');   // returns false (as of JS 1.8.1/FF3.6)
+o.propertyIsEnumerable('constructor'); // returns false
+o.propertyIsEnumerable('firstMethod'); // returns false
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.propertyisenumerable', 'Object.prototype.propertyIsEnumerable')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.Object.propertyIsEnumerable")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Statements/for...in", "for...in")}}</li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/proto/index.html b/files/pt-br/web/javascript/reference/global_objects/object/proto/index.html
new file mode 100644
index 0000000000..11221c8bf9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/proto/index.html
@@ -0,0 +1,203 @@
+---
+title: Object.prototype.__proto__
+slug: Web/JavaScript/Reference/Global_Objects/Object/proto
+tags:
+  - Depreciado
+  - ECMAScript 2015
+  - JavaScript
+  - Objeto
+  - Propriedade
+  - Prototipo
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/proto
+---
+<div class="warning">
+<p><strong>Cuidado:</strong> Alterando o <code>[[Prototype]]</code> de um objeto é, pela natureza que as engines do Javascript modernos otimizam os acessos à propriedades, uma operação muito lenta, em <strong><em>TODOS </em></strong>os mecanismos browsers e JavaScript. Os efeitos no desempenho de alteração na herança são sutis e distantes, e não se limitam simplesmente ao tempo gasto em na declaração <code>obj.__proto__ = ...</code>, mas podem se estender para <strong><em>qualquer</em></strong> código que tenha acesso a <strong><em>qualquer</em></strong> objeto cujo <code>[[Prototype]]</code> foi alterado. Se você se preocupa com desempenho, evite configurar o <code>[[Prototype]]</code> de um objeto. Ao invés disso, crie um novo objeto com o <code>[[Prototype]]</code> desejado usando {{jsxref("Object.create()")}}.</p>
+</div>
+
+<div class="warning">
+<p><strong>Cuidado:</strong> Enquanto <code>Object.prototype.__proto__</code> é suportado hoje em dia em quase todos os navegadores, a existência e o comportamento exato foram padronizados na especificação ECMAScript 2015 como um recurso legado para assegurar compatibilidade com os navegadores. Para melhor suporte, recomenda-se que apenas {{jsxref("Object.getPrototypeOf()")}} seja usado em vez disso.</p>
+</div>
+
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code>__proto__</code> de {{jsxref("Object.prototype")}} é uma propriedade de acesso (uma função getter e uma setter) que expõe o interno <code>[[Prototype]]</code> (ou um objeto ou {{jsxref("Global_Objects/null", "null")}}) de um objeto o qual é acessado.</p>
+
+<p>O uso de <code>__proto__</code> é controverso, e foi desencorajado. Nunca foi incluído originalmente na especificação do idioma EcmaScript, mas os navegadores modernos decidiram implementá-lo de qualquer maneira. Somente recentemente, a propriedade <code>__proto__</code> foi padronizada na especificação de linguagem ECMAScript 2015 para navegadores para garantir compatibilidade, e então ser suportada no futuro. É obsoleta a favor de {{jsxref("Object.getPrototypeOf")}}/{{jsxref("Reflect.getPrototypeOf")}} e {{jsxref("Object.setPrototypeOf")}}/{{jsxref("Reflect.setPrototypeOf")}} (embora ainda, definir <code>[[Prototype]]</code> é uma operação lenta que deve ser evitada se o desempenho for uma preocupação).</p>
+
+<p>A propriedade <code>__proto__</code> também pode ser usada em uma definição literal de objeto para definir o objeto <code>[[Prototype]]</code> na criação, como uma alternativa para {{jsxref("Object.create()")}}. Veja: <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">object initializer / literal syntax</a>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush: js">var shape = {};
+var circle = new Circle();
+
+// Define o objeto prototype.
+// OBSOLETO. Isto é somente exemplo. NÃO FAÇA ISSO em código real.
+shape.__proto__ = circle;
+
+// Retorna o objeto prototype
+console.log(shape.__proto__ === circle); // true
+</pre>
+
+<pre class="brush: js">var shape = function () {
+};
+var p = {
+    a: function () {
+        console.log('aaa');
+    }
+};
+shape.prototype.__proto__ = p;
+
+var circle = new shape();
+
+circle.a();//aaa
+
+console.log(shape.prototype === circle.__proto__);//true
+
+//ou
+
+var shape = function () {
+};
+var p = {
+    a: function () {
+        console.log('a');
+    }
+};
+
+var circle = new shape();
+circle.__proto__ = p;
+
+
+circle.a(); //  a
+
+console.log(shape.prototype === circle.__proto__);//false
+
+//ou
+
+function test() {
+}
+test.prototype.myname = function () {
+    console.log('myname');
+
+}
+var a = new test()
+
+console.log(a.__proto__ === test.prototype);//true
+
+a.myname();//myname
+
+
+//ou
+
+var fn = function () {
+};
+fn.prototype.myname = function () {
+    console.log('myname');
+}
+
+var obj = {
+    __proto__: fn.prototype
+};
+
+
+obj.myname();//myname
+</pre>
+
+<p>Nota: são dois underscores(underlines), seguidos de cinco caracteres "proto", seguidos por mais dois underscores(underlines).</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função getter de <code>__proto__</code> expõe o valor interno de <code>[[Prototype]]</code> de um objeto. Para objetos criado usando um objeto literal, este valor é {{jsxref("Object.prototype")}}. Para os objetos criados usando literais de matrizes, esse valor é {{jsxref("Array.prototype")}}. Para funções, esse valor é {{jsxref("Function.prototype")}}. Para objeto criados usando <code>new fun</code>, onde <code>fun</code> é uma função construtora built-in fornecida pelo JavaScript ({{jsxref("Array")}}, {{jsxref("Boolean")}}, {{jsxref("Date")}}, {{jsxref("Number")}}, {{jsxref("Object")}}, {{jsxref("String")}}, e assim por diante — incluindo novos construtores adicionados como evolução do JavaScript), este valor é sempre <code>fun.prototype</code>. Para objetos criados usando <code>new fun</code>, onde <code>fun</code> é uma função definida em um script, esse valor é o valor de  <code>fun.prototype</code>. (Ou seja, se o construtor não retornou um outro objeto explicitamente, ou o <code>fun.prototype</code> foi reatribuído desde que a instância foi criada).</p>
+
+<p>O setter <code>__proto__</code> permite ao <code>[[Prototype]]</code> de um objeto sejá mutável. O objeto deve ser extensível de acordo com {{jsxref("Object.isExtensible()")}}: se não for, um erro {{jsxref("Global_Objects/TypeError", "TypeError")}} é emitido. O valor fornecido deve ser um objeto ou {{jsxref("Global_Objects/null", "null")}}. Fornecer qualquer outro valor não fará nada.</p>
+
+<p>Para entender como os prototypes são usados para herança, veja o artigo:<a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">Inheritance and the prototype chain</a>.</p>
+
+<p>A propriedade <code>__proto__</code> é simplesmente uma propriedade acessora {{jsxref("Object.prototype")}} consistindo de uma função getter e setter. Um acesso de propriedade para <code>__proto__</code> que eventualmente consulte {{jsxref("Object.prototype")}} irá encontrar esta propriedade, mas um acesso que não consulta {{jsxref("Object.prototype")}} não a encontrará. Se alguma outra propriedade <code>__proto__</code> for encontrada antes de consultar {{jsxref("Object.prototype")}}, essa propriedade irá ocultar a que encontrou {{jsxref("Object.prototype")}}.</p>
+
+<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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Included in the (normative) annex for additional ECMAScript legacy features for Web browsers (note that the specification codifies what is already in implementations).</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-additional-properties-of-the-object.prototype-object', 'Object.prototype.__proto__')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatIE("11")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
+
+<p>Enquanto a especificação ECMAScript 2015 dita que o suporte para <code>__proto__</code> é requerido <em>somente</em> para navegadores (apesar de ser normativo), outros ambientes podem suportar também para uso legado.</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.setPrototypeOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/object/prototype/index.html
new file mode 100644
index 0000000000..5897f91327
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/prototype/index.html
@@ -0,0 +1,226 @@
+---
+title: Object.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Object/prototype
+tags:
+  - JavaScript
+  - Objeto
+  - Propriedade
+translation_of: Web/JavaScript/Reference/Global_Objects/Object
+---
+<div>{{JSRef("Global_Objects", "Object")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A propriedade <code><strong>Object.prototype</strong></code> representa o {{jsxref("Global_Objects/Object", "Object")}} protótipo do objeto.</p>
+
+<p>{{js_property_attributes(0, 0, 0)}}</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Praticamente todos os objetos em JavaScript descendem de {{jsxref("Global_Objects/Object", "Object")}}; todos os métodos e propriedades herdados de <code>Object.prototype</code>, embora possam ser sobrescritos (exceto um <code>Objeto</code> com protótipo nulo, i.e. <code>Object.create(null)</code>). Por exemplo, outros protótipos construtores sobrescrevem a propriedade construtora e fornece seus próprios {{jsxref("Object.prototype.toString()", "toString()")}} métodos.</p>
+
+<p>Modificações no <code>Objeto protótipo</code> do objeto são propagadas a <strong>todos</strong> objetos através do encadeamento de protótipos, a menos que as propriedades e métodos  submetidos às mudanças sejam sobrescritos mais além no encadeamento dos protótipos. Este recurso oferece um mecânismo muito poderoso apesar de perigoso para <em>sobrescrita</em> e <em>extensão</em> de objetos.</p>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("Object.prototype.constructor")}}</dt>
+ <dd>Especifica a função que cria um objeto protótipo.</dd>
+ <dt>{{jsxref("Object.prototype.__proto__")}} {{non-standard_inline}}</dt>
+ <dd>Aponta para o objeto que foi usado como protótipo quando o objeto foi instanciado.</dd>
+ <dt>{{jsxref("Object.prototype.__noSuchMethod__")}} {{non-standard_inline}}</dt>
+ <dd>Permite definir uma função que será executada quando um membro indefinido do objeto for chamado como método.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__count__")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Usado para retornar um número de propriedades enumeráveis diretamente num objeto definido pelo usuário, mas foi removida.</s></dd>
+ <dt><s class="obsoleteElement">{{jsxref("Object.prototype.__parent__")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Usado para apontar a um contexto do objeto, mas foi removida.</s></dd>
+</dl>
+
+<h2 id="Methods" name="Methods">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Object.prototype.__defineGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Associa uma função com uma propriedade que, quando acessada, executa uma função e retorna seu valor de retorno.</dd>
+ <dt>{{jsxref("Object.prototype.__defineSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Associa uma função com uma propriedade que, quando definida, executa uma função que modifica a propriedade.</dd>
+ <dt>{{jsxref("Object.prototype.__lookupGetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Retorna a função associada com a propriedade específicada pelo {{jsxref("Object.defineGetter", "__defineGetter__")}} método.</dd>
+ <dt>{{jsxref("Object.prototype.__lookupSetter__()")}} {{non-standard_inline}} {{deprecated_inline}}</dt>
+ <dd>Retorna a função associada com a propriedade especificada pelo {{jsxref("Object.defineSetter", "__defineSetter__")}} método.</dd>
+ <dt>{{jsxref("Object.prototype.hasOwnProperty()")}}</dt>
+ <dd>Retorna um boolean indicando se um objeto contém a propriedade especificada como uma propriedade direta de um objeto e não herdada através da cadeia de protótipo.</dd>
+ <dt>{{jsxref("Object.prototype.isPrototypeOf()")}}</dt>
+ <dd>Retorna uma indicação booleana se o objeto especificado está na cadeia de protótipo do objeto este método é chamado.</dd>
+ <dt>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</dt>
+ <dd>Retorna um boolean indicando se o atributo interno <a href="/en-US/docs/ECMAScript_DontEnum_attribute" title="ECMAScript_DontEnum_attribute">ECMAScript DontEnum attribute</a> está definido.</dd>
+ <dt>{{jsxref("Object.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna uma string contendo o código de um objeto literal representando o objeto que este método é  chamado; você pode usar este valor para criar um novo objeto.</dd>
+ <dt>{{jsxref("Object.prototype.toLocaleString()")}}</dt>
+ <dd>Chama {{jsxref("Object.toString", "toString()")}}.</dd>
+ <dt>{{jsxref("Object.prototype.toString()")}}</dt>
+ <dd>Retorna uma representação do objeto em forma de string.</dd>
+ <dt>{{jsxref("Object.prototype.unwatch()")}} {{non-standard_inline}}</dt>
+ <dd>Remove um ponto de escuta da propriedade do objeto.</dd>
+ <dt>{{jsxref("Object.prototype.valueOf()")}}</dt>
+ <dd>Retorna o valor primitivo do objeto especificado.</dd>
+ <dt>{{jsxref("Object.prototype.watch()")}} {{non-standard_inline}}</dt>
+ <dd>Adiciona um ponto de escuta à propriedade do objeto.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("Object.prototype.eval()")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Usado para avaliar uma string de código JavaScript no contexto do objeto especificado, mas foi removido.</s></dd>
+</dl>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<p>Quando é alterado o comportamento de um método de um Objeto protótipo, considere injetar código envolvendo sua extensão antes ou depois ta lógica existente. Por exemplo, este (não testado) código irá pré-condicionalmente executar uma lógica personalizada antes da lógica embutida ou a extensão de alguém será executada.</p>
+
+<p>Quando uma função é chamada os argumentos para a chamada são segurados no array de argumentos como "variável". Por exemplo, na chamada "minhaFuncao(a, b, c)", os argumentos no corpo da minhaFuncao irão conter 3 elementos array correspondentes a (a, b, c). Quando modificamos os protótipos com ganchos, simplesmente passamos <em>this</em> &amp; a variável <em>arguments</em> (o estado de chamada) para o comportamento atual pela chamada <em>apply()</em> na função. Este padrão pode ser usado por qualquer protótipo, tal como <em>Node.prototype, Function.prototype, etc.</em></p>
+
+<pre><code>var current = Object.prototype.valueOf;
+
+// Desde que minha propriedade "-prop-value" é transversal e não está
+// sempre na mesma cadeia de protótipo, desejo modificar Object.prototype:
+Object.prototype.valueOf = function() {
+  if (this.hasOwnProperty("-prop-value") {
+    return this["-prop-value"];
+  } else {
+    // Isto não parece com um de meus objetos, então vamos retroceder ao
+    // comportamento padrão para reproduzir o comportamento atual o que
+    // pudermos. O <em>apply</em> se comporta como o<em>"super"</em> em outras linguagens.
+    // Mesmo que <em>valueOf()</em> não receba argumentos, alguns outros ganchos podem.
+    return current.apply(this, arguments);
+  }
+}</code></pre>
+
+<p>Desde que JavaScript não tem exatamente objetos de subclasse, protótipo é uma forma usual de trabalhar para fazer um objeto "classe base" de certas funções que agem como objetos. Por exemplo:</p>
+
+<pre class="brush: js">var Person = function() {
+  this.canTalk = true;
+  this.greet = function() {
+    if (this.canTalk) {
+      console.log('Hi, I\'m ' + this.name);
+    }
+  };
+};
+
+var Employee = function(name, title) {
+  this.name = name;
+  this.title = title;
+  this.greet = function() {
+    if (this.canTalk) {
+      console.log("Hi, I'm " + this.name + ", the " + this.title);
+    }
+  };
+};
+Employee.prototype = new Person();
+
+var Customer = function(name) {
+  this.name = name;
+};
+Customer.prototype = new Person();
+
+var Mime = function(name) {
+  this.name = name;
+  this.canTalk = false;
+};
+Mime.prototype = new Person();
+
+var bob = new Employee('Bob', 'Builder');
+var joe = new Customer('Joe');
+var rg = new Employee('Red Green', 'Handyman');
+var mike = new Customer('Mike');
+var mime = new Mime('Mime');
+bob.greet();
+joe.greet();
+rg.greet();
+mike.greet();
+mime.greet();
+</pre>
+
+<p>O retorno será:</p>
+
+<pre>Hi, I'm Bob, the Builder
+Hi, I'm Joe
+Hi, I'm Red Green, the Handyman
+Hi, I'm Mike
+</pre>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition. Implemented in JavaScript 1.0.</td>
+   <td>Padrão</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.3.1', 'Object.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype', 'Object.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade com Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Aspecto</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Aspecto</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico.</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p> </p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/seal/index.html b/files/pt-br/web/javascript/reference/global_objects/object/seal/index.html
new file mode 100644
index 0000000000..a3b6ffa66a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/seal/index.html
@@ -0,0 +1,173 @@
+---
+title: Object.seal()
+slug: Web/JavaScript/Reference/Global_Objects/Object/seal
+tags:
+  - objeto selar selado
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/seal
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Object.seal()</strong></code> sela um Objeto, evitando que novas propriedades sejam adicionadas à ele e marcando todas as propriedades existentes como não configuráveis. Valores das propriedades atuais ainda podem ser alterados desde que essas propriedades sejam graváveis (writable).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.seal(<var>obj</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O Objeto que deve ser selado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O Objeto sendo selado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Por padrão, objetos são {{jsxref("Object.isExtensible()", "extensible", "", 1)}} (novas propriedades podem ser adicionadas à eles). Selar um objeto evita que novas propriedades sejam adicionadas e marca todas as propriedades existentes como não configuráveis. Isto tem o efeito de tornar as propriedades no objeto fixas e imutáveis. Tornando todas as propriedades não configuráveis também evita que as mesmas sejam convertidas de propriedades de dados para propriedades de acesso e vice-versa, mas não evita que os valores das propriedades de dados sejam alterados. A tentativa de deletar ou adicionar propriedades à um objeto selado, ou converter uma propriedade de dado para uma propriedade de acesso ou vice-versa, irá falhar, seja silenciosamente como jogando o erro {{jsxref("TypeError")}} (mais comumente, mas não exclusivamente, quando em modo rigoroso {{jsxref("Strict_mode", "strict mode", "", 1)}} de código).</p>
+
+<p>A cadeia de prototipação permanece intocada. Entretanto, a propriedade {{jsxref("Object.proto", "__proto__")}} {{deprecated_inline}} é selada também.</p>
+
+<p>Retorna a referência ao Objeto passado.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var obj = {
+  prop: function() {},
+  foo: 'bar'
+};
+
+// Novas propriedades podem ser adicionadas, propriedades existentes podem ser alteradas ou removidas.
+obj.foo = 'baz';
+obj.lumpy = 'woof';
+delete obj.prop;
+
+var o = Object.seal(obj);
+
+o === obj; // true
+Object.isSealed(obj); // === true
+
+// Alterar o valor das propriedades em um objeto selado ainda funciona.
+obj.foo = 'quux';
+
+// Mas você não pode converter propriedades de dados em propriedades de acesso, e vice-versa.
+Object.defineProperty(obj, 'foo', { get: function() { return 'g'; } }); // throws a TypeError
+
+// Agora quaisquer mudanças, que não sejam aos valores da das propriedades, irão falhar.
+obj.quaxxor = 'the friendly duck'; // silently doesn't add the property
+delete obj.foo; // silently doesn't delete the property
+
+// e em modo rigoroso (strict mode) tais tentativas irão jogar erros do tipo TypeErrors.
+function fail() {
+  'use strict';
+  delete obj.foo; // throws a TypeError
+  obj.sparky = 'arf'; // throws a TypeError
+}
+fail();
+
+// Tentativas através do Object.defineProperty também irão falhar.
+Object.defineProperty(obj, 'ohai', { value: 17 }); // lança um erro do tipo TypeError
+Object.defineProperty(obj, 'foo', { value: 'eit' }); // altera o valor da propriedade existente
+</pre>
+
+<h2 id="Notas">Notas</h2>
+
+<p>No ES5, se o argumento passado à este método não é um objeto (primitivo) , irá causar um erro {{jsxref("TypeError")}}. No ES6, qualquer argumento que não seja um objeto será tratado como se fosse um objeto ordinário selado e simplesmente irá retorná-lo</p>
+
+<pre class="brush: js">Object.seal(1);
+// TypeError: 1 não é um Objeto (código ES5)
+
+Object.seal(1);
+// 1                             (código ES6)
+</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('ES5.1', '#sec-15.2.3.8', 'Object.seal')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no Javascript 1.8.5.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.seal', 'Object.seal')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.seal', 'Object.seal')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_Browsers">Compatibilidade em Browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("6")}}</td>
+   <td>{{CompatGeckoDesktop("2.0")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("12")}}</td>
+   <td>{{CompatSafari("5.1")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.isSealed()")}}</li>
+ <li>{{jsxref("Object.preventExtensions()")}}</li>
+ <li>{{jsxref("Object.isExtensible()")}}</li>
+ <li>{{jsxref("Object.freeze()")}}</li>
+ <li>{{jsxref("Object.isFrozen()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.html b/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.html
new file mode 100644
index 0000000000..1a27cbd99e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/setprototypeof/index.html
@@ -0,0 +1,249 @@
+---
+title: Object.setPrototypeOf()
+slug: Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Método(2)
+  - Objeto
+  - Prototype
+  - Protótipo(2)
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/setPrototypeOf
+---
+<p>{{JSRef}}</p>
+
+<p>O método <code><strong>Object.setPrototypeOf()</strong></code> configura o 'prototype' (i.e., a propriedade interna <code>[[Prototype]]</code>)  de um objeto específico para outro objeto ou {{jsxref("null")}}.</p>
+
+<div class="warning">
+<p><strong>Atenção:</strong> Mudar o <code>[[Prototype]]</code> de um objeto é, pela natureza de como os modernos mecanismos JavaScript otimizam os acessos de propriedade, uma operação muito lenta, em <strong><em>todos</em></strong> navegadores e mecanismos JavaScript. O efeito sobre o desempenho de alterar a herança são sutis e vastas e não se limitam simplesmente ao tempo gasto em <code>obj.__proto__ = ...</code> statement, mas pode estender a <strong><em>qualquer</em></strong> código que tem acesso a <strong><em>qualquer</em></strong> objeto cujo <code>[[Prototype]]</code> foi alterado. Se você se preocupa com desempenho, você deveria evitar configurar o <code>[[Prototype]]</code> de um objeto. Em vez disso, crie um novo objeto com o <code>[[Prototype]] desejado usando</code> {{jsxref("Object.create()")}}.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>Object.setPrototypeOf(<var>obj</var>, <var>prototype</var>);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto que deve ter seu 'prototype' definido.</dd>
+ <dt><code>prototype</code></dt>
+ <dd>O novo 'prototype' do objeto  (um objeto ou {{jsxref("null")}}).</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto especificado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Gera uma exceção {{jsxref("TypeError")}} se o objeto cujo <code>[[Prototype]]</code> é para ser modificado não for extensível de acordo com {{jsxref("Object.isExtensible()")}}. Não faz nada se o parâmetro '<code>prototype'</code> não for um objeto ou {{jsxref("null")}} (ex., número, texto, boleano, ou {{jsxref("undefined")}}). Caso contrário, este método muda o <code>[[Prototype]]</code> do <code>obj</code> para um novo valor.</p>
+
+<p><code>Object.setPrototypeOf() é uma especificação</code> ECMAScript 2015. É geralmente considerada a maneira correta de definir o 'prototype' de um objeto, em relação à propriedade mais controversa {{jsxref("Object.prototype.__proto__")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var dict = Object.setPrototypeOf({}, null);
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Usando a propriedade mais antiga {{jsxref("Object.prototype.__proto__")}}, nós podemos facilmente definir <code>Object.setPrototypeOf</code> se já não estiver disponível:</p>
+
+<pre class="brush: js">// Funciona somente no Chrome e FireFox, não funciona no IE:
+Object.setPrototypeOf = Object.setPrototypeOf || function(obj, proto) {
+  obj.__proto__ = proto;
+  return obj;
+}
+</pre>
+
+<h2 id="Adicionando_'Prototype'_em_cadeia">Adicionando 'Prototype' em cadeia</h2>
+
+<p>Uma combinação de <code>Object.getPrototypeOf() e</code> {{jsxref("Object.proto", "Object.prototype.__proto__")}} permite anexar toda uma cadeia de 'prototype' a um novo objeto 'prototype':</p>
+
+<pre class="brush: js">/**
+*** Object.appendChain(@object, @prototype)
+*
+* Acrescente o primeiro 'prototype' não nativo de uma cadeia a um novo 'prototype'.
+* Retorna @object (se for um valor primitivo, será transformado em um objeto).
+*
+*** Object.appendChain(@object [, "@arg_name_1", "@arg_name_2", "@arg_name_3", "..."], "@function_body")
+*** Object.appendChain(@object [, "@arg_name_1, @arg_name_2, @arg_name_3, ..."], "@function_body")
+*
+* Adicione o primeiro 'prototype' não nativo de uma cadeia ao objeto nativo Function.prototype, então anexar a nova função
+* Function(["@arg"(s)], "@function_body") àquela cadeia.
+* Retorna a função.
+*
+**/
+
+Object.appendChain = function(oChain, oProto) {
+  if (arguments.length &lt; 2) {
+    throw new TypeError('Object.appendChain - Argumentos insuficientes');
+  }
+  if (typeof oProto !== 'object' &amp;&amp; typeof oProto !== 'string') {
+    throw new TypeError('segundo argumento de Object.appendChain deve ser um objeto ou uma string');
+  }
+
+  var oNewProto = oProto,
+      oReturn = o2nd = oLast = oChain instanceof this ? oChain : new oChain.constructor(oChain);
+
+  for (var o1st = this.getPrototypeOf(o2nd);
+    o1st !== Object.prototype &amp;&amp; o1st !== Function.prototype;
+    o1st = this.getPrototypeOf(o2nd)
+  ) {
+    o2nd = o1st;
+  }
+
+  if (oProto.constructor === String) {
+    oNewProto = Function.prototype;
+    oReturn = Function.apply(null, Array.prototype.slice.call(arguments, 1));
+    this.setPrototypeOf(oReturn, oLast);
+  }
+
+  this.setPrototypeOf(o2nd, oNewProto);
+  return oReturn;
+}
+</pre>
+
+<h3 id="Exemplos_2">Exemplos</h3>
+
+<h4 id="Primeiro_exemplo_Adicionar_uma_cadeia_a_um_'prototype'.">Primeiro exemplo: Adicionar uma cadeia a um 'prototype'.</h4>
+
+<pre class="brush: js">function Mammal() {
+  this.isMammal = 'yes';
+}
+
+function MammalSpecies(sMammalSpecies) {
+  this.species = sMammalSpecies;
+}
+
+MammalSpecies.prototype = new Mammal();
+MammalSpecies.prototype.constructor = MammalSpecies;
+
+var oCat = new MammalSpecies('Felis');
+
+console.log(oCat.isMammal); // 'yes'
+
+function Animal() {
+  this.breathing = 'yes';
+}
+
+Object.appendChain(oCat, new Animal());
+
+console.log(oCat.breathing); // 'yes'
+</pre>
+
+<h4 id="Segundo_exemplo_Transformar_um_valor_primitivo_em_uma_instância_de_seu_construtor_e_anexar_sua_cadeia_a_um_'prototype'.">Segundo exemplo: Transformar um valor primitivo em uma instância de seu construtor e anexar sua cadeia a um 'prototype'.</h4>
+
+<pre class="brush: js">function MySymbol() {
+  this.isSymbol = 'yes';
+}
+
+var nPrime = 17;
+
+console.log(typeof nPrime); // 'number'
+
+var oPrime = Object.appendChain(nPrime, new MySymbol());
+
+console.log(oPrime); // '17'
+console.log(oPrime.isSymbol); // 'yes'
+console.log(typeof oPrime); // 'object'
+</pre>
+
+<h4 id="Terceiro_exemplo_Anexar_uma_cadeia_ao_objeto_Function.prototype_e_anexar_uma_nova_função_a_essa_cadeia.">Terceiro exemplo: Anexar uma cadeia ao objeto Function.prototype e anexar uma nova função a essa cadeia.</h4>
+
+<pre class="brush: js">function Person(sName) {
+  this.identity = sName;
+}
+
+var george = Object.appendChain(new Person('George'),
+                                'console.log("Hello guys!!");');
+
+console.log(george.identity); // 'George'
+george(); // 'Hello guys!!'
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-object.setprototypeof', 'Object.setProtoypeOf')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.setprototypeof', 'Object.setProtoypeOf')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome("34")}}</td>
+   <td>{{CompatGeckoDesktop("31")}}</td>
+   <td>{{CompatIE("11")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<p> </p>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Configuração</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("31")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatSafari("9")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Reflect.setPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.prototype.isPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.getPrototypeOf()")}}</li>
+ <li>{{jsxref("Object.prototype.__proto__")}} </li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.html b/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.html
new file mode 100644
index 0000000000..4d857a21e4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/tolocalestring/index.html
@@ -0,0 +1,115 @@
+---
+title: Object.prototype.toLocaleString()
+slug: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString
+tags:
+  - JavaScript
+  - Method
+  - Object
+  - Objeto
+  - Prototipo
+  - Prototype
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toLocaleString
+---
+<p>{{JSRef}}</p>
+
+<p>O método <code><strong>toLocaleString()</strong></code> retorna uma cadeia de caracteres (<em>string</em>) representando o objeto. Este método é feito para ser sobrescrito por objetos derivados para propósitos de localização específica.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-prototype-tolocalestring.html")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>obj</var>.toLocaleString()</pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string</em> representando o objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>toLocaleString</code> do {{jsxref("Object")}} returna o resultado da chamada {{jsxref("Object.toString", "toString()")}}.</p>
+
+<p>Esta função é provida para dar aos objetos um método <code>toLocaleString</code> genérico, mesmo que nem todos os usem. Veja a lista abaixo.</p>
+
+<h3 id="Objetos_sobrescrevendo_toLocaleString">Objetos sobrescrevendo toLocaleString</h3>
+
+<ul>
+ <li>{{jsxref("Array")}}: {{jsxref("Array.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Number")}}: {{jsxref("Number.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("Date")}}: {{jsxref("Date.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("TypedArray")}}: {{jsxref("TypedArray.prototype.toLocaleString()")}}</li>
+ <li>{{jsxref("BigInt")}}: {{jsxref("BigInt.prototype.toLocaleString()")}}</li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Sobrescrita_do_Array_toLocaleString">Sobrescrita do Array toLocaleString()</h3>
+
+<p>Em objetos {{jsxref("Array")}}, {{jsxref("Array.toLocaleString", "toLocaleString()")}} pode ser usado para imprimir valores do arranjo como uma <em>string</em>, opcionalmente com identificadores de localização específicos (como símbolos monetários) atrelados a eles:</p>
+
+<p>Por exemplo:</p>
+
+<pre class="brush: js notranslate">const testArray = [4, 7, 10];
+
+let euroPrices = testArray.toLocaleString('fr', { style: 'currency', currency: 'EUR'});
+// "4,00 €,7,00 €,10,00 €"</pre>
+
+<h3 id="Sobrescrita_do_Date_toLocaleString">Sobrescrita do Date toLocaleString()</h3>
+
+<p>Em objetos {{jsxref("Date")}}, {{jsxref("Date.toLocaleString", "toLocaleString()")}} é usado para imprimir datas mais apropriadas para localizações específicas:</p>
+
+<p>Por exemplo:</p>
+
+<pre class="brush: js notranslate">const testDate = new Date(Date.now());
+// "Date Fri May 29 2020 18:04:24 GMT+0100 (British Summer Time)"
+
+let deDate = testDate.toLocaleString('de');
+// "29.5.2020, 18:04:24"
+
+var frDate = testDate.toLocaleString('fr');
+//"29/05/2020 à 18:04:24"</pre>
+
+<h3 id="Sobrescrita_de_Number_toLocaleString">Sobrescrita de Number toLocaleString()</h3>
+
+<p>Em objetos {{jsxref("Number")}}, {{jsxref("Number.toLocaleString", "toLocaleString()")}} é usado para imprimir números para localizações específicas, e.g. com os corretos separadores:</p>
+
+<p>Por exemplo:</p>
+
+<pre class="brush: js notranslate">const testNumber = 2901234564;
+// "2901234564"
+
+let deNumber = testNumber.toLocaleString('de');
+// "2.901.234.564"
+
+let frNumber = testNumber.toLocaleString('fr');
+// "2 901 234 564"</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.tolocalestring', 'Object.prototype.toLocaleString')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Object.toLocaleString")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/object/tosource/index.html
new file mode 100644
index 0000000000..e0a8edcaa5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/tosource/index.html
@@ -0,0 +1,136 @@
+---
+title: Object.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/Object/toSource
+tags:
+  - JavaScript
+  - Method
+  - Non-standard
+  - Não padronizado
+  - Object
+  - Objeto
+  - Obsoleto
+  - Prototipo
+  - Prototype
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toSource
+---
+<div>{{JSRef}} {{obsolete_header}}</div>
+
+<p>O método <strong><code>toSource()</code></strong> retorna uma cadeia de caracteres (<em>string</em>) representando o código fonte do objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>Object.toSource();
+<var>obj</var>.toSource();
+</code></pre>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma <em>string</em> representando o código fonte do objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>toSource()</code> retorna os seguintes valores:</p>
+
+<ul>
+ <li>Para o objeto embutido {{jsxref("Object")}}, <code>toSource()</code> retorna a seguinte <em>string</em> indicando que o código fonte não está disponível:
+
+  <pre class="brush: js notranslate">function Object() {
+    [native code]
+}
+</pre>
+ </li>
+ <li>Para instâncias de {{jsxref("Object")}}, <code>toSource()</code> returna a <em>string</em> representando o código fonte.</li>
+</ul>
+
+<p>Você pode chamar <code>toSource()</code> enquanto debuga para examinar os conteúdos de um objeto.</p>
+
+<h3 id="Sobrescrevendo_o_método_toSource">Sobrescrevendo o método <code>toSource()</code></h3>
+
+<p>É seguro para objetos sobrescreverem o método <code>toSource()</code>. Por exemplo:</p>
+
+<pre class="brush: js notranslate">function Person(name) {
+  this.name = name;
+}
+
+Person.prototype.toSource = function Person_toSource() {
+  return 'new Person(' + uneval(this.name) + ')';
+};
+
+console.log(new Person('Joe').toSource()); // ---&gt; new Person("Joe")
+</pre>
+
+<h3 id="Métodos_toSource_embutidos">Métodos <code>toSource()</code> embutidos</h3>
+
+<p>Cada tipo principal do JavaScript tem seu próprio método <code>toSource()</code>. Esses objetos são:</p>
+
+<ul>
+ <li>{{jsxref("Array.prototype.toSource()")}}  — objeto {{jsxref("Array")}}.</li>
+ <li>{{jsxref("Boolean.prototype.toSource()")}}  — objeto {{jsxref("Boolean")}}.</li>
+ <li>{{jsxref("Date.prototype.toSource()")}}  — objeto {{jsxref("Date")}}.</li>
+ <li>{{jsxref("Function.prototype.toSource()")}}  — objeto {{jsxref("Function")}}.</li>
+ <li>{{jsxref("Number.prototype.toSource()")}}  — objeto {{jsxref("Number")}}.</li>
+ <li>{{jsxref("RegExp.prototype.toSource()")}}  — objeto {{jsxref("RegExp")}}.</li>
+ <li>{{jsxref("String.prototype.toSource()")}}  — objeto {{jsxref("String")}}.</li>
+ <li>{{jsxref("Symbol.prototype.toSource()")}}  — objeto {{jsxref("Symbol")}}.</li>
+ <li><code>Math.toSource()</code> — Retorna a <em>string</em> "Math".</li>
+</ul>
+
+<h3 id="Limitações_em_objetos_cíclicos">Limitações em objetos cíclicos</h3>
+
+<p>Em case de objetos que contém referências para eles mesmos, e.g. uma lista ligada cíclica ou uma árvore que pode ser percorrida pelos dois sentidos, <code>toSource()</code> não irá recriar a auto-referência, como no Firefox 24. Por exemplo:</p>
+
+<pre class="brush: js notranslate">var obj1 = {};
+var obj2 = { a: obj1 };
+obj1.b = obj2;
+
+console.log('Cyclical: ' + (obj1.b.a == obj1));
+
+var objSource = obj1.toSource(); // retorna "({b:{a:{}}})"
+
+obj1 = eval(objSource);
+
+console.log('Cyclical: ' + (obj1.b.a == obj1));
+</pre>
+
+<p>Se uma estrutura cíclica é empregada e <code>toSource()</code> é necessário, o objeto deve prover uma sobrescrita para <code>toSource()</code>, ou usando a referência para um construtor ou provendo uma função anônima.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toSource">Usando <code>toSource()</code></h3>
+
+<p>O seguinte código define o tipo do objeto <code>Dog</code> e cria <code>theDog</code>, um objeto do tipo <code>Dog</code>:</p>
+
+<pre class="brush: js notranslate">function Dog(name, breed, color, sex) {
+  this.name = name;
+  this.breed = breed;
+  this.color = color;
+  this.sex = sex;
+}
+
+theDog = new Dog('Gabby', 'Lab', 'chocolate', 'female');
+</pre>
+
+<p>Chamando o método <code>toSource()</code> de <code>theDog</code> mostra o código fonte JavaScript que define o objeto:</p>
+
+<pre class="brush: js notranslate">theDog.toSource();
+// returns ({name:"Gabby", breed:"Lab", color:"chocolate", sex:"female"})
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Não faz parte de nenhum padrão.</p>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nessa página é gerada de dados estruturados. Se você quiser contribuir a esses dados, por favor cheque <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data </a>e nos mande um pull request.</div>
+
+<p>{{Compat("javascript.builtins.Object.toSource")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.html
new file mode 100644
index 0000000000..1e1453778e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/tostring/index.html
@@ -0,0 +1,163 @@
+---
+title: Object.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/Object/toString
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/toString
+---
+<div>{{JSRef("Global_Objects", "Object")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O método <code><strong>toString()</strong></code> retorna uma string representando o objeto.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>obj</var>.toString()</code></pre>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Todo objeto possui um método <code>toString()</code> que é chamado automaticamente quando o objeto precisa ser representado como um valor em texto ou quando o objeto é referenciado de uma maneira que requeira uma string. Por padrão, o método <code>toString()</code> é herdado de todo objeto descendente de  <code>Object</code>. Se e o método não é sobrescrito em um objeto personalizado, <code>toString()</code> retorna "[object <em>type</em>]", onde <code><em>type</em></code> é o tipo do objeto. O código a seguir ilustra isso:</p>
+
+<pre class="brush: js">var o = new Object();
+o.toString();           // retorna [object Object]
+</pre>
+
+<div class="note">
+<p><strong>Note:</strong> Starting in JavaScript 1.8.5 <code>toString()</code> called on {{jsxref("Global_Objects/null", "null")}} returns <code>[object <em>Null</em>]</code>, and {{jsxref("Global_Objects/undefined", "undefined")}} returns <code>[object <em>Undefined</em>]</code>, as defined in the 5th Edition of ECMAScript and a subsequent Errata. See {{anch("Example:_Using_toString_to_detect_object_type", "Using toString to detect object type")}}.</p>
+</div>
+
+<h2 id="Examples" name="Examples">Examples</h2>
+
+<h3 id="Example:_Overriding_the_default_toString_method" name="Example:_Overriding_the_default_toString_method">Exemplo: Sobrepondo o método inicial <code>toString</code> </h3>
+
+<p>Você pode criar uma função para ser chamada no lugar do método <code>toString()</code>. O método <code>toString()</code> não requer parâmetros e deve retornar uma string. O método <code>toString()</code> criado por você pode ter o valor que quiser, mas será mais útil se usar informações do objeto.</p>
+
+<p>O código abaixo define o objeto <code>Dog</code> e cria <code>theDog</code>, um objeto do tipo <code>Dog</code>:</p>
+
+<pre class="brush: js">function Dog(name, breed, color, sex) {
+  this.name = name;
+  this.breed = breed;
+  this.color = color;
+  this.sex = sex;
+}
+
+theDog = new Dog('Gabby', 'Lab', 'chocolate', 'female');
+</pre>
+
+<p>Se você chamar o método <code>toString()</code> neste objeto, ele retornará o valor original herdado de {{jsxref("Global_Objects/Object", "Object")}}:</p>
+
+<pre class="brush: js">theDog.toString(); // returns [object Object]
+</pre>
+
+<p>O código abaixo cria e faz com que <code>dogToString()</code> sobrescreva o <code>toString()</code> original. Esta função gera uma string contendo <strong>name, breed, color, and sex</strong> do objeto, na forma de "<code>propriedade = valor;</code>".</p>
+
+<pre class="brush: js">Dog.prototype.toString = function dogToString() {
+  var ret = 'Dog ' + this.name + ' is a ' + this.sex + ' ' + this.color + ' ' + this.breed;
+  return ret;
+}
+</pre>
+
+<p>Usando este código, toda vez que <code>theDog</code> for usado em um texto (string), JavaScript automaticamente chamará a função <code>dogToString()</code>, a qual retornará:</p>
+
+<pre>Dog Gabby is a female chocolate Lab
+</pre>
+
+<h3 id="Example:_Using_toString_to_detect_object_type" name="Example:_Using_toString_to_detect_object_type">Exemplo: Usando <code>toString()</code> para detectar a classe do objeto</h3>
+
+<p><code>toString()</code> pode ser usado com qualquer objeto e permite que você pegue sua classe. Para usar <code>Object.prototype.toString()</code> com qualquer objeto, deverá chamar {{jsxref("Function.prototype.call()")}} ou {{jsxref("Function.prototype.apply()")}} nele, passando o objeto que quer inspecionar como o primeiro parâmetro, chamado <code>thisArg</code>.</p>
+
+<pre class="brush: js">var toString = Object.prototype.toString;
+
+toString.call(new Date);    // [object Date]
+toString.call(new String);  // [object String]
+toString.call(Math);        // [object Math]
+
+// Since JavaScript 1.8.5
+toString.call(undefined);   // [object Undefined]
+toString.call(null);        // [object Null]
+</pre>
+
+<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. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.2', 'Object.prototype.toString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Call on {{jsxref("Global_Objects/null", "null")}} returns <code>[object <em>Null</em>]</code>, and {{jsxref("Global_Objects/undefined", "undefined")}} returns <code>[object <em>Undefined</em>]</code></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.tostring', 'Object.prototype.toString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.html
new file mode 100644
index 0000000000..a78642c377
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/valueof/index.html
@@ -0,0 +1,110 @@
+---
+title: Object.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/Object/valueOf
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/valueOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>valueOf()</strong></code> retorna o valor primitivo do objeto especificado.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/object-prototype-valueof.html")}}</div>
+
+<p class="hidden">A fonte desse exemplo interativo está armazenada em um repositório GitHub. Se você quiser de contrinuir para o projeto interativo de exemplos, por favor, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><var>object</var>.valueOf()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O valor primitivo do objeto especificado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>JavaScript chama o método <code>valueOf</code> para converter um objeto em um valor primitivo. Você raramente precisará chamar o método <code>valueOf</code> por ele mesmo; O JavaScript chamará ele automaticamente quando encontrar um objeto onde um valor primitivo for esperado.</p>
+
+<p>Por padrão, o método <code>valueOf</code> é herdado por cada objeto descendente de {{jsxref("Object")}}. Todo núcleo embutido do objeto sobrescreve esse método para retornar um valor apropriado. Se um objeto não tem um valor primitivo, <code>valueOf</code> retorna o próprio objeto.</p>
+
+<p>Você pode usar <code>valueOf</code> dentro do seu próprio código para converter um objeto embutido, em um valor primitivo. Quando você criar um objeto customizado, você pode sobrescrever <code>Object.prototype.valueOf()</code> para chamar um método customizado ao invés do método padrão  {{jsxref("Object")}}.</p>
+
+<h3 id="Sobrescrevendo_valueOf_para_objetos_customizados">Sobrescrevendo <code>valueOf</code> para objetos customizados</h3>
+
+<p>Você pode criar uma função para ser chamada no lougar do método padrão <code>valueOf</code>. Sua função não pode ter nenhum argumento.</p>
+
+<p>Suponha que você tem um tipo de objeto <code>MyNumberType</code> e você quer criar um método <code>valueOf</code> para ele. O código a seguir atribui uma função definida por usuário para o método <code>valueOf</code> desse objeto:</p>
+
+<pre class="brush: js">MyNumberType.prototype.valueOf = function() { return customPrimitiveValue; };</pre>
+
+<p>Com o código anterior no lugar, a qualquer hora um objeto do tipo <code>MyNumberType</code> é usado em um contexto onde deve ser representado como um valor primitivo, o JavaScript chama automaticamente a função definida no código anterior.</p>
+
+<p>Um método <code>valueOf</code> de um objeto é geralmente chamado pelo JavaScript, mas você pode chamá-lo se quiser da seguinte maneira:</p>
+
+<pre class="brush: js">myNumberType.valueOf()</pre>
+
+<div class="note">
+<p><strong>Nota:</strong> Objetos em contexto de string convertidos através do método {{jsxref("Object.toString", "toString()")}}, o que é diferente de objetos {{jsxref("String")}} convertendo para string primiriva utlizando <code>valueOf</code>. Todos os objetos têm uma conversão string, somente se "<code>[object <em>type</em>]</code>". Mas muitos objetos não convertem para number, boolean, or function.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_valueOf">Usando <code>valueOf</code></h3>
+
+<pre class="brush: js">function MyNumberType(n) {
+    this.number = n;
+}
+
+MyNumberType.prototype.valueOf = function() {
+    return this.number;
+};
+
+var myObj = new MyNumberType(4);
+myObj + 3; // 7
+</pre>
+
+<h2 id="Espeficações">Espeficações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Cometário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.2.4.4', 'Object.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object.prototype.valueof', 'Object.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.prototype.valueof', 'Object.prototype.valueOf')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_browser">Compatibilidade do browser</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nessa página é gerada à partidad de dados estruturados. Se você quiser contribuir para os dados, por favor, vá até <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie o pull request.</div>
+
+<p>{{Compat("javascript.builtins.Object.valueOf")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+ <li>{{jsxref("parseInt", "parseInt()")}}</li>
+ <li>{{jsxref("Symbol.toPrimitive")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/object/values/index.html b/files/pt-br/web/javascript/reference/global_objects/object/values/index.html
new file mode 100644
index 0000000000..a95e01a704
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/object/values/index.html
@@ -0,0 +1,139 @@
+---
+title: Object.values()
+slug: Web/JavaScript/Reference/Global_Objects/Object/values
+translation_of: Web/JavaScript/Reference/Global_Objects/Object/values
+---
+<div>{{JSRef}} {{SeeCompatTable}}</div>
+
+<p>O método <code><strong>Object.values()</strong></code> retorna um array com os valores das propriedades de um dado objeto, na mesma ordem provida pelo {{jsxref("Statements/for...in", "for...in")}} laço (sendo a diferença que o laço for-in também enumera as propriedades na cadeia prototype).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Object.values(<var>obj</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>obj</code></dt>
+ <dd>O objeto cujos valores das propriedades enumeradas serão retornados.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um array contendo os valores das propriedades enumeradas do dado objeto.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>Object.values()</code> retorna um array cujos elementos são os valores das propriedades enumeradas encontradas no objeto. A ordem das propriedades é a mesma que a dada pelo laço sobre os valores da propriedade do objeto manualmente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">var obj = { foo: "bar", baz: 42 };
+console.log(Object.values(obj)); // ['bar', 42]
+
+// array como objeto
+var obj = { 0: 'a', 1: 'b', 2: 'c' };
+console.log(Object.values(obj)); // ['a', 'b', 'c']
+
+// array como objeto com ordenação de chave aleatória
+var an_obj = { 100: 'a', 2: 'b', 7: 'c' };
+console.log(Object.values(an_obj)); // ['b', 'c', 'a']
+
+// getFoo é a propriedade a qual não é enumerável
+var my_obj = Object.create({}, { getFoo: { value: function() { return this.foo; } } });
+my_obj.foo = "bar";
+console.log(Object.values(my_obj)); // ['bar']
+
+// argumento não-objeto será coagido num objeto
+console.log(Object.values("foo")); // ['f', 'o', 'o']
+</pre>
+
+<h2 id="Biblioteca_de_Suporte">Biblioteca de Suporte</h2>
+
+<p><code><font face="Open Sans, Arial, sans-serif">Para adicionar compatibilidade ao suporte de  </font>Object.values</code> em ambientes antigos que nativamente não o suportam, você pode encontrar uma biblioteca de suporte nos repositórios <a href="https://github.com/tc39/proposal-object-values-entries">tc39/proposal-object-values-entries</a> ou no <a href="https://github.com/es-shims/Object.values">es-shims/Object.values</a>.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object.values', 'Object.values')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Aspecto</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome(51.0)}} [1]</td>
+   <td>{{CompatGeckoDesktop(47)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}} [2]</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Aspecto</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome para Android</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(51.0)}} [1]</td>
+   <td>{{CompatGeckoMobile(47)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(51.0)}} [1]</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Por trás de uma flag.</p>
+
+<p>[2] Ver <a href="https://bugs.webkit.org/show_bug.cgi?id=150131">bug 150131</a>.</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Object.keys()")}}</li>
+ <li>{{jsxref("Object.entries()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("Object.prototype.propertyIsEnumerable()")}}</li>
+ <li>{{jsxref("Object.create()")}}</li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.html b/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.html
new file mode 100644
index 0000000000..a2d1ea3c8b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/parsefloat/index.html
@@ -0,0 +1,171 @@
+---
+title: parseFloat()
+slug: Web/JavaScript/Reference/Global_Objects/parseFloat
+translation_of: Web/JavaScript/Reference/Global_Objects/parseFloat
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<p>A função <code><strong>parseFloat()</strong></code><strong> </strong>analisa um argumento string e retorna um número de ponto flutuante.</p>
+
+<h2 id="Síntaxe">Síntaxe</h2>
+
+<pre class="syntaxbox">parseFloat(<em>string</em>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>string</code></dt>
+ <dd>Uma string que representa o valor a ser analisado.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>parseFloat</code> é uma função top-level e não está associada a nenhum objeto.</p>
+
+<p><code>parseFloat</code> analisa um argumento string, e retorna um numero de ponto flutuante. Se ele encontrar <span id="result_box" lang="pt"><span>um carácter diferente de</span> <span>um sinal</span> <span>(</span><span>+</span> <span>ou -)</span></span>, numeral (0-9), um ponto decimal, ou um expoente, e<span id="result_box" lang="pt"><span>le retorna</span> <span>o valor</span> <span>até esse ponto</span> <span>e ignora</span> <span>esse caractere e</span> <span>todos os caracteres</span> <span>seguintes. Espaços a direita e a esquerda s</span></span>ão permitidos.</p>
+
+<p>Se o primeiro carácter não puder ser convertido para um número, <code>parseFloat</code> retorna <code>NaN</code>.</p>
+
+<p>Para propósitos aritméticos, o valor <code>NaN</code> não é um número de qualquer raiz. Você pode chamar a função {{jsxref("isNaN")}} para determinar se o resultado do <code>parseFloat</code> é <code>NaN</code>. Se <code>NaN</code> for passado em operações aritméticas, a operação também retornará <code>NaN</code>.</p>
+
+<p><code>parseFloat</code> também pode analisar e retornar o valor <code>Infinity</code>. Você pode usar a função {{jsxref("isFinite")}} para determinar se a função é um número finito (not <code>Infinity</code>, <code>-Infinity</code>, ou <code>NaN</code>).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="parseFloat_retornando_um_número"><code>parseFloat</code> retornando um número</h3>
+
+<p>O exemplo a seguir sempre retorna <strong>3.14</strong></p>
+
+<pre class="brush:js">parseFloat("3.14");
+parseFloat("314e-2");
+parseFloat("0.0314E+2");
+parseFloat("3.14more non-digit characters");
+</pre>
+
+<h3 id="parseFloat_retornando_NaN"><code>parseFloat</code> retornando NaN</h3>
+
+<p>O exemplo a seguir retorna <code>NaN</code></p>
+
+<pre class="brush: js">parseFloat("FF2");
+</pre>
+
+<h3 id="A_função_stricter_parse">A função stricter parse</h3>
+
+<p><span id="result_box" lang="pt"><span>As vezes é útil</span> <span>ter uma maneira</span> <span>mais rigorosa</span> <span>para analisar</span> <span>valores float</span><span>,</span> <span>expressões regulares podem</span> <span>ajudar:</span></span></p>
+
+<pre class="brush: js">var filterFloat = function (value) {
+    if(/^(\-|\+)?([0-9]+(\.[0-9]+)?|Infinity)$/
+      .test(value))
+      return Number(value);
+  return NaN;
+}
+
+console.log(filterFloat('421'));               // 421
+console.log(filterFloat('-421'));              // -421
+console.log(filterFloat('+421'));              // 421
+console.log(filterFloat('Infinity'));          // Infinity
+console.log(filterFloat('1.61803398875'));     // 1.61803398875
+console.log(filterFloat('421e+0'));            // NaN
+console.log(filterFloat('421hop'));            // NaN
+console.log(filterFloat('hop1.61803398875'));  // NaN
+
+</pre>
+
+<p>Observe que este código é somente um exemplo; ele<span id="result_box" lang="pt"> <span>não aceita</span> <span>números válidos</span><span>, tais como</span> <span>1.</span> <span>ou</span> <span>0,5</span><span>.</span></span></p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.2.3', 'parseFloat')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-parsefloat-string', 'parseFloat')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-parsefloat-string', 'parseFloat')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compátibilidade_nos_navegadores">Compátibilidade nos navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li>
+ <li>{{jsxref("Number.parseFloat()")}}</li>
+ <li>{{jsxref("Number.parseInt()")}}</li>
+ <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/parseint/index.html b/files/pt-br/web/javascript/reference/global_objects/parseint/index.html
new file mode 100644
index 0000000000..ba7d40aa86
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/parseint/index.html
@@ -0,0 +1,224 @@
+---
+title: parseInt()
+slug: Web/JavaScript/Reference/Global_Objects/parseInt
+translation_of: Web/JavaScript/Reference/Global_Objects/parseInt
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A função <code><strong>parseInt()</strong></code> analisa um argumento <code>string</code> e retorna um inteiro na <code>base</code> especificada.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox">parseInt(<em>string</em>, <em>base</em>);</pre>
+
+<h2 id="Parameters" name="Parameters">Parâmetros</h2>
+
+<dl>
+ <dt><code>string</code></dt>
+ <dd>
+ <p>O valor a analisar. Se o argumento <code>string</code> não for uma string, então o valor é convertido para uma string (utilizando a operação abstrata <code><a href="http://www.ecma-international.org/ecma-262/6.0/#sec-tostring">ToString</a></code>). Os espaços em branco na <code>string</code> são ignorados.</p>
+ </dd>
+</dl>
+
+<dl>
+ <dt><code>base</code></dt>
+ <dd>Um inteiro entre 2 e 36 que representa a <em>base</em> da <code>string (</code>sistemas numéricos matemáticos<code>) </code>mencionada no parâmetro anterior. Especifique <code>10</code> para o sistema numérico decimal comumente usado por humanos. <strong>Sempre especifique este parâmetro</strong> para eliminar confusão do leitor e para garantir o comportamento esperado. Implementações diferentes produzem resultados diferentes quando <code>base</code> não é especificado, normalmente assumindo o valor como 10.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um número inteiro analisado a partir da string fornecida. Se o primeiro caracter não puder ser convertido para um número, {{jsxref("NaN")}} é retornado.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>A função <code>parseInt</code> converte seu primeiro argumento para uma string, analisa, e retorna um inteiro ou <code>NaN</code>. Se não <code>NaN</code>, o valor retornado será a representação decimal inteira do primeiro argumento obtido como um número na base especificada. Por exemplo, uma<em>base</em> 10 indica para converter de um número decimal, 8 octal, 16 hexadecimal, e assim por diante. Para bases acima de <code>10</code>, as letras do alfabeto indicam numerais maiores que <code>9</code>. Por exemplo, para números hexadecimais (base 16), <code>A</code> até <code>F</code> são usados.</p>
+
+<p>Se <code>parseInt</code> encontrar um caracter que não seja um numeral na base especificada, ele o ignora e a todos os caracteres subsequentes e retorna o valor inteiro analisado até aquele ponto. <code>parseInt</code> trunca números para valores inteiros. Espaços no início e fim são permitidos.</p>
+
+<p>Se <var>base</var> é <code>undefined</code> ou 0 (ou ausente), JavaScript assume o seguinte:</p>
+
+<ul>
+ <li>Se a <code>string</code> de entrada começa com "0x" ou "0X", a <var>base</var> é 16 (hexadecimal) e o restante da string é analisado.</li>
+ <li>Se a <code>string</code> de entrada começa com "0", a <var>base</var> é oito (octal) ou 10 (decimal).  Exatamente qual base é escolhida é dependente da implementação. O ECMAScript 5 especifica que 10 (decimal) seja utilizado, mas nem todos os browsers suportam isso ainda. Por essa razão <strong>sempre especifique uma base quando estiver usando <code>parseInt</code></strong>.</li>
+ <li>Se a <code>string</code> de entrada começa com qualquer outro valor, a base é 10 (decimal).</li>
+</ul>
+
+<p>Se o primeiro caracter não puder ser convertido para um número, <code>parseInt</code> retorna <code>NaN</code>.</p>
+
+<p>Para propósitos aritméticos, o valor <code>NaN</code> não é um número em qualquer base. Você pode chamar a função {{jsxref("Global_Objects/isNaN", "isNaN")}} para determinar se o resultado de <code>parseInt</code> é <code>NaN</code>. Se <code>NaN</code> for passado em operações aritméticas, o resultado da operação também será <code>NaN</code>.</p>
+
+<p>Para converter um número para seu literal string em uma base específica use <code>intValue.toString(base)</code>.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_parseInt" name="Example:_Using_parseInt">Exemplo: Usando <code>parseInt</code></h3>
+
+<p>Os seguintes exemplos sempre retornam <strong><code>15</code></strong>:</p>
+
+<pre>parseInt(" 0xF", 16);
+parseInt(" F", 16);
+parseInt("17", 8);
+parseInt(021, 8);
+parseInt("015", 10);
+parseInt(15.99, 10);
+parseInt("FXX123", 16);
+parseInt("1111", 2);
+parseInt("15*3", 10);
+parseInt("15e2", 10);
+parseInt("15px", 10);
+parseInt("12", 13);
+</pre>
+
+<p>Os seguintes exemplos sempre retornam <strong><code>NaN</code></strong>:</p>
+
+<pre>parseInt("Hello", 8); // Não é realmente um número
+parseInt("546", 2);   // Dígitos não são válidos para representações binárias
+</pre>
+
+<p>Os seguintes exemplos sempre retornam <strong><code>-15</code></strong>:</p>
+
+<pre>parseInt("-F", 16);
+parseInt("-0F", 16);
+parseInt("-0XF", 16);
+parseInt(-15.1, 10)
+parseInt(" -17", 8);
+parseInt(" -15", 10);
+parseInt("-1111", 2);
+parseInt("-15e1", 10);
+parseInt("-12", 13);
+</pre>
+
+<p>O seguinte exemplo retorna <strong><code>224</code></strong>:</p>
+
+<pre>parseInt("0e0", 16);
+</pre>
+
+<h2 id="Interpretação_octal_sem_informar_a_base">Interpretação octal sem informar a base</h2>
+
+<p>Embora desencorajado pelo ECMAScript 3 e proibido pelo ECMAScript 5, muitas implementações interpretam uma string numérica começando com um <code>0</code> como octal. O exemplo abaixo pode ter um resultado octal, ou ele pode ter um resultado decimal.  <strong>Sempre especifique uma base para evitar este comportamento não confiável.</strong></p>
+
+<pre>parseInt("0e0"); // 0
+parseInt("08"); // 0, '8' não é um dígito octal.
+</pre>
+
+<h3 id="O_ECMAScript_5_remove_a_interpretação_octal">O ECMAScript 5 remove a interpretação octal</h3>
+
+<p>A especificação ECMAScript 5 da funcão <code>parseInt</code> não permite mais que as implementações tratem Strings começando com o caracter 0 como um valor octal. O ECMAScript 5 declara:</p>
+
+<p>A função <code>parseInt</code> produz um valor inteiro ditado pela interpretação do conteúdo de uma argumento string de acordo com uma base específicada. Espaços em branco no início da string são ignorados. Se a base for undefined ou <code>0</code>, ela é assumida como <code>10</code> exceto quando o número começa com os pares de caracter <code>0x</code> or <code>0X</code>, e neste caso a base 16 é assumida. Se a base é <code>16</code>, o número pode também opcionalmente começar com os pares de caracter <code>0x</code> or <code>0X</code>.</p>
+
+<p>Isto difere do ECMAScript 3, que desencoraja mas permite a interpretação octal.</p>
+
+<p>Muitas implementações não adotaram este comportamento a partir de 2013, e porque browser antigos devem ser suportados, <strong>sempre especifique uma base</strong>.</p>
+
+<h2 id="Uma_função_de_análise_mais_rigorosa">Uma função de análise mais rigorosa</h2>
+
+<p><span id="result_box" lang="pt"><span class="hps">É</span> <span class="hps">útil</span> <span class="hps">em algum momento</span> <span class="hps">ter uma maneira</span> <span class="hps">mais rigorosa</span> <span class="hps">para analisar</span> <span class="hps">valores inteiros</span><span>.</span> <span class="hps">Expressões regulares podem</span> <span class="hps">ajudar:</span></span></p>
+
+<pre class="brush: js">filterInt = function (value) {
+  if(/^(\-|\+)?([0-9]+|Infinity)$/.test(value))
+    return Number(value);
+  return NaN;
+}
+
+console.log(filterInt('421'));               // 421
+console.log(filterInt('-421'));              // -421
+console.log(filterInt('+421'));              // 421
+console.log(filterInt('Infinity'));          // Infinity
+console.log(filterInt('421e+0'));            // NaN
+console.log(filterInt('421hop'));            // NaN
+console.log(filterInt('hop1.61803398875'));  // NaN
+console.log(filterInt('1.61803398875'));     // NaN
+</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>ECMAScript 1st Edition.</td>
+   <td>Padrão</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.2.2', 'parseInt')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-parseint-string-radix', 'parseInt')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_Also" name="See_Also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li>
+ <li>{{jsxref("Number.parseFloat()")}}</li>
+ <li>{{jsxref("Number.parseInt()")}}</li>
+ <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li>
+ <li>{{jsxref("Number.toString()")}}</li>
+ <li>{{jsxref("Object.valueOf")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html
new file mode 100644
index 0000000000..eec13d056a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/all/index.html
@@ -0,0 +1,245 @@
+---
+title: Promise.all()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/all
+tags:
+  - ECMAScript 2015
+  - ECMAScript6
+  - JavaScript
+  - Method
+  - Promise
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Promise.all(iterable)</strong></code> retorna uma única {{jsxref("Promise")}} que resolve quando todas as promises no argumento iterável forem resolvidas ou quando o iterável passado como argumento não contém promises. É rejeitado com o motivo da primeira promise que foi rejeitada.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/promise-all.html")}}</p>
+
+<div class="hidden">
+<p>A fonte para essa demonstração interativa está em um repositório no GitHub. Se você quiser contribuir para esse projeto de demonstrações iterativas, por favor, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envienos um pull request.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>Promise.all(iterable)</var>;</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>iterable</dt>
+ <dd>Um objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Iteration_protocols">iterável</a>, como um {{jsxref("Array")}} ou {{jsxref("String")}}.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<ul>
+ <li>Uma {{jsxref("Promise")}}<strong> já resolvida</strong> se o iterável passado for vazio.</li>
+ <li>Uma {{jsxref("Promise")}} <strong>resolvida assíncronamente</strong> se o iterável passado não conter promises. Nota, Google Chrome 58 retorna uma promise <strong>já resolvida</strong> nesse caso.</li>
+ <li>Uma {{jsxref("Promise")}} <strong>pendente</strong> em todos os outros casos. Essa promise retornada é então resolvida/rejeitada <strong>assíncronamente</strong> (tão logo a pilha esteja vazia) quando todas as promises no dado iterável forem resolvidas, ou se alguma das promises for rejeitada. Veja o exemplo sobre "Assincronia ou sincronia da Promise.all" abaixo. Os valores retornados estarão na ordem em que as promises foram passadas. independentemente da ordem em que forem concluídas.</li>
+</ul>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Esse método pode ser usado para agregar resultados de várias promises.</p>
+
+<h3 id="Resolução">Resolução</h3>
+
+<p>A promise retornada é resolvida com um array contendo <strong>todos</strong> os valores dos iteráveis passados como argumento (como valores que não são promises).</p>
+
+<ul>
+ <li>Se um iterável vazio é passado, então esse método retorna (sincronamente) uma promise já resolvida.</li>
+ <li>Se todas as promises passadas forem resolvidas, ou não forem promises, a promise retornada por <code>Promise.all</code> é resolvida assincronamente.</li>
+</ul>
+
+<h3 id="Rejeição">Rejeição</h3>
+
+<p>Se qualquer uma das promises passadas for rejeitada, <code>Promise.all</code> assíncronamente é rejeitada com o valor da promise rejeitada, independentemente se outras promises foram resolvidas.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_Promise.all">Utilizando Promise.all </h3>
+
+<p><code>Promise.all</code> espera que todas as promises sejam resolvidas (ou a primeira rejeição).</p>
+
+<pre class="notranslate"><code class="language-js">var p1 = Promise.resolve(3);
+var p2 = 1337;
+var p3 = new Promise((resolve, reject) =&gt; {
+  setTimeout(() =&gt; {
+    resolve("foo");
+  }, 100);
+});
+
+Promise.all([p1, p2, p3]).then(valores=&gt; {
+  console.log(valores); // [3, 1337, "foo"]
+});</code>
+</pre>
+
+<p>Se o iterável conter valores que não são promises, eles serão ignorados, mas ainda serão contados no array da promise retornada (se a promise for resolvida):</p>
+
+<pre class="notranslate"><code class="language-js">// Essa será considerada como se o iterável passado fosse vazio, logo ela será resolvido
+var p = Promise.all([1,2,3]);
+// Essa será considerada como se o iterável passado contém apenas a promise resolvida com o valor "444", logo ela é resolvida
+var p2 = Promise.all([1,2,3, Promise.resolve(444)]);
+// Esse será considerada como se o iterável passado contém apenas o valor de rejeição "555" da promise, logo ela é rejeitada
+var p3 = Promise.all([1,2,3, Promise.reject(555)]);
+
+// Utilizando setTimeout para executar código depois que a pilha estiver vazia
+setTimeout(function() {
+    console.log(p);
+    console.log(p2);
+    console.log(p3);
+});
+
+// logs
+// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[3] }
+// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[4] }
+// Promise { &lt;estado&gt;: "rejeitada", &lt;razão&gt;: 555 }</code>
+</pre>
+
+<h3 id="Assincronia_ou_sincronia_da_Promise.all">Assincronia ou sincronia da Promise.all</h3>
+
+<p>O exemplo a seguir demonstra a assincronia (ou sincronia, se o iterável passado for fazio) de <code>Promise.all</code>:</p>
+
+<pre class="notranslate"><code class="language-js">// Passamos o argumento como um array de promises que já estão resolvidas para disparar Promise.all a mais rápido possível
+var arrayPromisesResolvidas = [Promise.resolve(33), Promise.resolve(44)];
+
+var p = Promise.all(arrayPromisesResolvidas);
+// Logando imediatamente o valor de p
+console.log(p);
+
+// Utilizando setTimeout para executar código depois que a pilha estiver vazia
+setTimeout(function() {
+    console.log('a pilha está vazia agora');
+    console.log(p);
+});
+
+// logs, em ordem:
+// Promise { &lt;estado&gt;: "pendente" }
+// a pilha está vazia agora
+// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[2] }</code>
+</pre>
+
+<p>A mesma coisa acontece se <code>Promise.all</code> for rejeitada:</p>
+
+<pre class="notranslate"><code class="language-js">var arrayPromisesMisturadas = [Promise.resolve(33), Promise.reject(44)];
+var p = Promise.all(arrayPromisesMisturadas);
+console.log(p);
+setTimeout(function() {
+    console.log('a pilha está vazia agora');
+    console.log(p);
+});
+
+// logs
+// Promise { &lt;estado&gt;: "pendente" }
+// a pilha está vazia agora
+// Promise { &lt;estado&gt;: "rejeitada", &lt;razão&gt;: 44 }</code>
+</pre>
+
+<p>Mas, <code>Promise.all</code> resolve sincromamente <strong>se e somente se</strong> o iterável passado for vazio:</p>
+
+<pre class="notranslate"><code class="language-js">var p = Promise.all([]); // será resolvida imediatamente
+var p2 = Promise.all([1337, "oi"]); // um valor que não é uma promise será ignorado, mas a avaliação será feita assíncronamente
+console.log(p);
+console.log(p2)
+setTimeout(function() {
+    console.log('a pilha está vazia agora');
+    console.log(p2);
+});
+
+// logs
+// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[0] }
+// Promise { &lt;estado&gt;: "pendente" }
+// a pilha está vazia agora
+// Promise { &lt;estado&gt;: "resolvida", &lt;valor&gt;: Array[2] }</code>
+</pre>
+
+<h3 id="Comportamente_de_falhar_rapidamente_de_Promise.all">Comportamente de falhar rapidamente de Promise.all</h3>
+
+<p><code>Promise.all</code> é rejeitada se qualquer um dos elementos for rejeitado. Por exemplo, se você passar quartro promises que resolvem após um intervalo de tempo e uma promise que rejeita imediatamente, então <code>Promise.all</code> será rejeitada imediatamente.</p>
+
+<pre class="notranslate"><code class="language-js">var p1 = new Promise((resolve, reject) =&gt; {
+  setTimeout(() =&gt; resolve('um'), 1000);
+});
+var p2 = new Promise((resolve, reject) =&gt; {
+  setTimeout(() =&gt; resolve('dois'), 2000);
+});
+var p3 = new Promise((resolve, reject) =&gt; {
+  setTimeout(() =&gt; resolve('três'), 3000);
+});
+var p4 = new Promise((resolve, reject) =&gt; {
+  setTimeout(() =&gt; resolve('quatro'), 4000);
+});
+var p5 = new Promise((resolve, reject) =&gt; {
+  reject(new Error('rejeitada'));
+});
+
+
+// Usando .catch:
+Promise.all([p1, p2, p3, p4, p5])
+.then(valores =&gt; {
+  console.log(valores);
+})
+.catch(erro =&gt; {
+  console.log(erro.message)
+});
+
+// No console:
+// "rejeitada"</code>
+</pre>
+
+<p>É possível mudar esse comportamente lidando com possíveis rejeições:</p>
+
+<pre class="brush: js line-numbers language-js notranslate"><code class="language-js">var p1 = new Promise((resolve, reject) =&gt; {
+  setTimeout(() =&gt; resolve('p1_resolução_atrasada'), 1000);
+});
+
+var p2 = new Promise((resolve, reject) =&gt; {
+  reject(new Error('p2_rejeição_imediata'));
+});
+
+Promise.all([
+  p1.catch(erro =&gt; { return erro }),
+  p2.catch(erro =&gt; { return erro }),
+]).then(valores =&gt; {
+  console.log(valores[0]) // "p1_resolução_atrasada"
+  console.log(valores[1]) // "Erro: p2_rejeição_imediata"
+})</code></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('ES2015', '#sec-promise.all', 'Promise.all')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>
+    <p>Definição inicial em um padrão ECMA.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-promise.all', 'Promise.all')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<div class="hidden">
+<p>Para contribuir para esse dado de compatibilidade, por favor, escreva um pull request para o repositório: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+</div>
+
+<p>{{Compat("javascript.builtins.Promise.all")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Promise.race()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.html
new file mode 100644
index 0000000000..770a4fd3a7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/allsettled/index.html
@@ -0,0 +1,64 @@
+---
+title: Promise.allSettled()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/allSettled
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/allSettled
+---
+<p>{{JSRef}}</p>
+
+<p>O método <code><strong>Promise.allSettled()</strong></code> retorna uma promessa que é resolvida após todas as promessas dadas serem resolvidas ou rejeitadas, com um array de objetos que descrevem o resultado de cada promessa.</p>
+
+<p>É tipicamente usado quando você tem múltiplas tarefas assíncronas que não são dependentes das conclusões umas das outras, ou quando você sempre quer ter o resultado de cada promessa.</p>
+
+<p>Para comparação, a promessa retornada por {{jsxref("Promise.all()")}} pode ser mais apropriada para tarefas que dependem umas das outras, ou se você precisa que todas as tarefas sejam rejeitadas quando apenas uma é. </p>
+
+<div>{{EmbedInteractiveExample("pages/js/promise-allsettled.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><em>promise</em>.allSettled(<em>iterable</em>);</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>iterable</code></dt>
+ <dd>Um objeto <a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterável</a>, como um {{jsxref("Array")}}, onde cada membro é uma <code>Promise</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma {{jsxref("Promise")}} <strong>pendente</strong> que vai ser <strong>preenchida assíncronamente</strong> quando todas as promessas na coleção fornecida forem completas, sendo aceitas ou rejeitadas. Quando isso acontecer, é retornado um array contendo um resultado para cada promessa passada como entrada.</p>
+
+<p>Para cada objeto no array retornado, existe uma string <code>status</code>. Se o status for <code>fulfilled</code>, então o campo <code>value</code> estará presente. Se o status for <code>rejected</code>, então o campo <code>reason</code> estará presente. O valor (value) ou o motivo da falha (reason) refletem o valor com que cada promessa foi completada (ou rejeitada).</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><a href="https://tc39.es/proposal-promise-allSettled/"><code>Promise.allSettled()</code> (TC39 Stage 4 Draft)</a></td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p class="hidden">Para contribuir com os dados de compatibilidae, por favor faça um pull request nesse repositório: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.Promise.allSettled")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Archive/Add-ons/Techniques/Promises">Promessas</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Using_promises">Usando promessas</a></li>
+ <li><a href="/en-US/docs/Learn/JavaScript/Asynchronous/Promises">Programando assincronamente de maneira elegante usando promessas</a></li>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Promise.all()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.html
new file mode 100644
index 0000000000..a39d4576d7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/catch/index.html
@@ -0,0 +1,138 @@
+---
+title: Promise.prototype.catch()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/catch
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/catch
+---
+<div>{{JSRef}}</div>
+
+<div>O método <strong>catch()</strong> retorna uma Promise e lida apenas com casos rejeitados. Ele possui o mesmo comportamento de quando chamamos {{jsxref("Promise.then", "Promise.prototype.then(undefined, onRejected)")}} (de fato, chamando <code>obj.catch(onRejected)</code> internamente é chamado <code>obj.then(undefined, onRejected)</code>).</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>p.catch(onRejected)</var>;
+
+p.catch(function(motivo) {
+   // rejeição
+});
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>onRejected</dt>
+ <dd>Uma {{jsxref("Function")}} chamada quando a <code>Promise</code> é rejeitada. Esta função possui um argumento:<br>
+ <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);"><strong>reason</strong></span></font> da rejeição.<br>
+       O motivo da rejeição.<br>
+ <br>
+ A Promise retornada pelo <code>catch()</code> é rejeitada apenas se <code>onRejected</code> cospe um erro ou se o o retorno da Promise foi rejeitada por si mesmo, ou seja, foi resolvida.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Internamente chamamos <code>Promise.prototype.then</code> sobre o objeto que é chamando passando parâmetros como <code>undefined</code> e <code>onRejected</code> no manipulador de eventos. Então retornamos o valor da chamada que é {{jsxref("Promise")}}.</p>
+
+<div class="warning">
+<p>O exemplo abaixo está cuspindo uma string. Isso é considerado uma má prática. Sempre cuspir uma instance de erro (Error). Em todo caso, a parte que faz a captura deve fazer verificaçoes sobre os argumentos para saber se é uma string ou um erro e você poderá perder informações valiosas como stack traces.</p>
+</div>
+
+<p><strong>Demonstração de uma camada interna:</strong></p>
+
+<pre class="brush: js notranslate">// Sobrescrevendo o techo original de  Promise.prototype.then/catch adicionando alguns logs
+(function(Promise){
+    var originalThen = Promise.prototype.then;
+    var originalCatch = Promise.prototype.catch;
+
+    Promise.prototype.then = function(){
+        console.log('&gt; &gt; &gt; &gt; &gt; &gt; chamando .then em %o com argumentos: %o', this, arguments);
+        return originalThen.apply(this, arguments);
+    };
+    Promise.prototype.catch = function(){
+        console.log('&gt; &gt; &gt; &gt; &gt; &gt; chamando .catch em %o com argumentos: %o', this, arguments);
+        return originalCatch.apply(this, arguments);
+    };
+
+})(this.Promise);
+
+
+// chamando um catch em uma Promise já resolvida.
+Promise.resolve().catch(function XXX(){});
+
+// logs:
+// &gt; &gt; &gt; &gt; &gt; &gt; chamando .catch na Promise{} com os argumentos: Arguments{1} [0: function XXX()]
+// &gt; &gt; &gt; &gt; &gt; &gt; chamando .then na Promise{} com os argumentos: Arguments{2} [0: undefined, 1: function XXX()]</pre>
+
+<h2 id="Description">Description</h2>
+
+<p>O método <code>catch</code> pode ser útil para manipulação de erros na composição da sua promise.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_catch">Usando o método <code>catch</code></h3>
+
+<pre class="brush: js notranslate">var p1 = new Promise(function(resolve, reject) {
+  resolve('Sucesso');
+});
+
+p1.then(function(value) {
+  console.log(value); // "Sucesso!"
+  throw 'Ah, não!';
+}).catch(function(e) {
+  console.log(e); // "Ah, não!"
+}).then(function(){
+  console.log('Após um catch, a sequencia é restaurada');
+}, function () {
+  console.log('Não engatilhado devido ao catch');
+});
+
+// O seguinte se comporta da mesma maneira que o anterior
+p1.then(function(value) {
+  console.log(value); // "Sucesso!"
+  return Promise.reject('Ah, não!');
+}).catch(function(e) {
+  console.log(e); // "Ah, não!"
+}).then(function(){
+  console.log('Após um catch, a sequencia é restaurada');
+}, function () {
+  console.log('Não engatilhado devido ao catch');
+});
+
+</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-promise.prototype.catch', 'Promise.prototype.catch')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition in an ECMA standard.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-promise.prototype.catch', 'Promise.prototype.catch')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
+
+
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Promise.catch")}}</p>
+
+
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Promise.prototype.then()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.html
new file mode 100644
index 0000000000..59dff0a6cf
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/finally/index.html
@@ -0,0 +1,100 @@
+---
+title: Promise.prototype.finally()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/finally
+tags:
+  - JavaScript
+  - Promises
+  - Referencia
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/finally
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>finally()</strong></code> retorna uma {{jsxref("Promise")}}. Quando a promise for estabelecida, tenha ela sido realizada ou rejeitada, executa-se a função callback especificada. Isso permite a execução de um código que acontecerá independentemente da <code>Promise</code> ter sido realizada (com sucesso) ou rejeitada (com falha).</p>
+
+<p>Assim, você pode evitar a duplicação do código em ambos os handlers {{jsxref("Promise.then", "then()")}} e {{jsxref("Promise.catch", "catch()")}} da <code>Promise</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>p.finally(quandoEstabelecida)</var>;
+
+p.finally(function() {
+   // concluída (realizada ou rejeitada)
+});
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>quandoEstabelecida</code></dt>
+ <dd>Uma {{jsxref("Function")}} chamada quando a <code>Promise</code> é concluída.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Retorna uma {{jsxref("Promise")}} onde o manipulador <code>finally</code> é definido como a função especificada, <code>quandoEstabelecida</code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>finally()</code> pode ser útil quando você deseja realizar algum tipo de processamento ou limpeza quando a promise for estabelecida, independentemente de seu resultado (sucesso ou falha).</p>
+
+<p>O método <code>finally()</code> é bastante similar a chamar <code>.then(quandoEstabelecida, quandoEstabelecida)</code>. Porém, existem algumas diferenças:</p>
+
+<ul>
+ <li>Ao passar a função na linha (entre os parênteses do método), você precisa passá-la apenas uma vez, ao invés de ser forçado a declará-la duas vezes ou a definir em uma variável.</li>
+ <li>O callback de <code>finally</code> não poderá receber nenhum argumento, já que não existem meios confiáveis de determinar se a promise foi realizada ou rejeitada. Seu uso é para quando você realmente <em>não se importa</em> com os possíveis motivos de uma falha ou possíveis valores retornados de um sucesso, não tendo, portanto, razão para fornecê-los.</li>
+ <li>Diferentemente de <code>Promise.resolve(2).then(() =&gt; {}, () =&gt; {})</code> (será resolvido como <code>undefined</code>), <code>Promise.resolve(2).finally(() =&gt; {})</code> será resolvido como <code>2</code>.</li>
+ <li>De maneira semelhante, diferentemente de <code>Promise.reject(3).then(() =&gt; {}, () =&gt; {})</code> (que será resolvido como <code>undefined</code>), <code>Promise.reject(3).finally(() =&gt; {})</code> será rejeitado como <code>3</code>.</li>
+</ul>
+
+<div class="note">
+<p><strong>Nota:</strong> Um <code>throw</code> (ou retorno de uma promise rejeitada) no callback de <code>finally</code> rejeitará a nova promise com a razão de rejeição especificada na chamada de <code>throw()</code>.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">let carregando = true;
+
+fetch(minhaRequisicao).then(function(resposta) {
+    var tipoConteudo = response.headers.get("content-type");
+    if(tipoConteudo &amp;&amp; tipoConteudo.includes("application/json")) {
+      return resposta.json();
+    }
+    throw new TypeError("Opa, isso não é JSON!");
+  })
+  .then(function(json) { /* processamento do seu JSON */ })
+  .catch(function(erro) { console.log(erro); })
+  .finally(function() { carregando = false; });
+
+</pre>
+
+<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><a href="https://github.com/tc39/proposal-promise-finally">TC39 proposal</a></td>
+   <td>Stage 4</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+<p class="hidden">To contribute to this compatibility data, please write a pull request against this repository: <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a>.</p>
+
+<p>{{Compat("javascript.builtins.Promise.finally")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Promise.prototype.then()")}}</li>
+ <li>{{jsxref("Promise.prototype.catch()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/index.html
new file mode 100644
index 0000000000..d3d0e76322
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/index.html
@@ -0,0 +1,174 @@
+---
+title: Promise
+slug: Web/JavaScript/Reference/Global_Objects/Promise
+tags:
+  - ECMAScript6
+  - JavaScript
+  - Promise
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise
+---
+<div>{{JSRef("Global_Objects", "Promise")}}</div>
+
+<p><strong><code>Promise</code></strong> é um objeto usado para processamento assíncrono. Um <code>Promise</code> (<em>de "promessa"</em>) representa um valor que pode estar disponível agora, no futuro ou nunca.</p>
+
+<div class="note">
+<p><strong>Nota:</strong> Esse artigo descreve o construtor <code>Promise,</code>os métodos e propriedades de tais objetos. Para aprender sobre como promises funcionam e como utilizá-los, é aconselhavel a leitura de <a href="/pt-BR/docs/Web/JavaScript/Guide/Usando_promises">utilizando promises</a>. O construtor é utilizado para embrulhar funções sem suporte ao conceito "promise".</p>
+</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Uma <code><strong>Promise</strong></code> representa um proxy para um valor que não é necessariamente conhecido quando a promessa é criada. Isso permite a associação de métodos de tratamento para eventos da ação assíncrona num caso eventual de sucesso ou de falha. Isto permite que métodos assíncronos retornem valores como métodos síncronos: ao invés do valor final, o método assíncrono retorna uma <em>promessa</em> ao valor em algum momento no futuro.</p>
+
+<p>Um <strong><code>Promise</code></strong> está em um destes estados: </p>
+
+<ul>
+ <li><em>pending (</em>pendente<em>)</em>: Estado inicial, que não foi realizada nem rejeitada.</li>
+ <li><em>fulfilled (</em>realizada): sucesso na operação.</li>
+ <li><em>rejected (</em>rejeitado):  falha na operação.</li>
+</ul>
+
+<p>Uma promessa pendente pode se tornar <em>realizada</em> com um valor ou <em>rejeitada</em> por um motivo (erro). Quando um desses estados ocorre, o método <code>then</code> do <code>Promise</code> é chamado, e ele chama o método de tratamento associado ao estado (<code>rejected</code> ou <code>resolved</code>).  Se a promessa foi realizada ou rejeitada quando o método de tratamento correspondente for associado, o método será chamado, deste forma não há uma condição de competição entre uma operação assíncrona e seus manipuladores que estão sendo associados.</p>
+
+<p>Como os métodos <code>Promise.prototype.then</code> e <code>Promise.prototype.catch</code>  retornam promises, eles podem ser encadeados — uma operação chamada <em>composição</em>.</p>
+
+<p><img alt="" src="https://mdn.mozillademos.org/files/8633/promises.png" style="height: 297px; width: 801px;"></p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>Promise.length</code></dt>
+ <dd>Propriedade length cujo valor é sempre 1 (número de argumentos do método construtor).</dd>
+ <dt>{{jsxref("Promise.prototype")}}</dt>
+ <dd>Representa o protótipo para o método construtor da <code>Promise</code>.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Promise.all", "Promise.all(lista)")}}</dt>
+ <dd>Retorna uma promise que é resolvida quando todas as promises no argumento <em>lista</em> forem resolvidas ou rejeitada assim que uma das promises da lista for rejeitada. Se a promise retornada for resolvida, ela é resolvida com um array dos valores das promises resolvidas da lista. Se a promise for rejeitada, ela é rejeitada com o motivo da primeira promise que foi rejeitada na lista. Este método pode ser útil para agregar resultados de múltiplas promises.</dd>
+ <dt>{{jsxref("Promise.race", "Promise.race(lista)")}}</dt>
+ <dd>Retorna uma promise que resolve ou rejeita assim que uma das promises do argumento lista resolve ou rejeita, com um valor ou o motivo daquela promise.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Promise.reject", "Promise.reject(motivo)")}}</dt>
+ <dd>Retorna um objeto <code>Promise</code> que foi rejeitado por um dado motivo.</dd>
+</dl>
+
+<dl>
+ <dt>{{jsxref("Promise.resolve", "Promise.resolve(valor)")}}</dt>
+ <dd>Retorna um objeto <code>Promise</code> que foi resolvido com um dado valor. Se o valor é <code>thenable</code> (possui um método <code>then</code>), a promise retornada "seguirá" este método, adotando esse estado eventual; caso contrário a promise retornada será realizada com o valor. Geralmente, se você quer saber se um valor é uma promise ou não, utilize {{jsxref("Promise.resolve", "Promise.resolve(valor)")}} e trabalhe com a valor de retorno que é sempre uma promise.</dd>
+</dl>
+
+<h2 id="Protótipo_Promise">Protótipo Promise</h2>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Propriedades')}}</p>
+
+<h3 id="Métodos_2">Métodos</h3>
+
+<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Métodos')}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Criando_uma_Promise">Criando uma Promise</h3>
+
+<pre class="brush: html notranslate" style="display: none;">&lt;button id="btn"&gt;Make a promise!&lt;/button&gt;
+&lt;div id="log"&gt;&lt;/div&gt;
+</pre>
+
+<p>Este pequeno exemplo mostra o mecanismo de uma <code>Promise</code>. O método <code>testPromise()</code> é chamado cada vez que {{HTMLElement("button")}} é clicado. Isso cria uma promise que resolverá, usando {{domxref("window.setTimeout()")}}, o contador de promise <code>promiseCount</code> (iniciando em 1) a cada 1 a 3s randomicamente. O construtor <code>Promise()</code> é usado para criar a promise.</p>
+
+<p>A realização da promise é simplesmente registrada, por meio de configuração na função callback de realização  usando {{jsxref("Promise.prototype.then()","p1.then()")}}. Alguns logs mostram como a parte síncrona do método é desacoplada da conclusão assíncrona da promise.</p>
+
+<pre class="brush: js notranslate">var promiseCount = 0;
+function testPromise() {
+  var thisPromiseCount = ++promiseCount;
+
+  var log = document.getElementById('log');
+  log.insertAdjacentHTML('beforeend', thisPromiseCount +
+      ') Started (&lt;small&gt;Sync code started&lt;/small&gt;)&lt;br/&gt;');
+
+  // Criamos uma nova promise: prometemos a contagem dessa promise (após aguardar 3s)
+  var p1 = new Promise(
+    // a função resolve() é chamada com a capacidade para resolver ou
+    // rejeitar a promise
+    function(resolve, reject) {
+      log.insertAdjacentHTML('beforeend', thisPromiseCount +
+          ') Promise started (&lt;small&gt;Async code started&lt;/small&gt;)&lt;br/&gt;');
+      // Isto é apenas um exemplo para criar assincronismo
+      window.setTimeout(
+        function() {
+          // Cumprimos a promessa !
+          resolve(thisPromiseCount)
+        }, Math.random() * 2000 + 1000);
+    });
+
+  // definimos o que fazer quando a promise for realizada
+  p1.then(
+    // apenas logamos a mensagem e o valor
+    function(val) {
+      log.insertAdjacentHTML('beforeend', val +
+          ') Promise fulfilled (&lt;small&gt;Async code terminated&lt;/small&gt;)&lt;br/&gt;');
+    });
+
+  log.insertAdjacentHTML('beforeend', thisPromiseCount +
+      ') Promise made (&lt;small&gt;Sync code terminated&lt;/small&gt;)&lt;br/&gt;');
+}
+</pre>
+
+<pre class="brush:js notranslate" style="display: none;">if ("Promise" in window) {
+  btn = document.getElementById("btn");
+   btn.addEventListener("click",testPromise);
+}
+else {
+  log = document.getElementById('log');
+  log.innerHTML = "Live example not available as your browser doesn't support the Promise interface.";
+}
+</pre>
+
+<p>Este exemplo é executado pelo click do botão. Você precisa de uma versão de navegedor com suporte a <code>Promise</code>. Clicando algumas vezes no botão num curto intervalo de tempo, você verá as diferentes promises sendo realizadas uma após a outra.</p>
+
+<p>{{EmbedLiveSample("Criando_uma_Promise", "500", "200")}}</p>
+
+<h3 id="Carregando_uma_imagem_com_XHR">Carregando uma imagem com XHR</h3>
+
+<p>Outro simples exemplo usando <code>Promise</code> e <code><a href="/en-US/docs/Web/API/XMLHttpRequest">XMLHTTPRequest</a></code> para carregar imagens está disponível no repositório GitHub MDN<a href="https://github.com/mdn/js-examples/blob/master/promises-test/index.html"> promise-test</a>. Você também pode <a href="https://mdn.github.io/js-examples/promises-test/">vê-lo em ação</a>. Cada passo é comentado e lhe permite acompanhar de perto a arquitetura de Promise e XHR.</p>
+
+<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><a href="https://github.com/domenic/promises-unwrapping">domenic/promises-unwrapping</a></td>
+   <td>Draft</td>
+   <td>Standardization work is taking place here.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-promise-objects', 'Promise')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition in an ECMA standard.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegador">Compatibilidade de Navegador</h2>
+
+<p>{{Compat("javascript.builtins.Promise")}}</p>
+
+<p>Veja também</p>
+
+<ul>
+ <li><a href="http://promisesaplus.com/">Promises/A+ specification</a></li>
+ <li><a href="http://www.html5rocks.com/en/tutorials/es6/promises/">Jake Archibald: JavaScript Promises: There and Back Again</a></li>
+ <li><a href="http://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript">Domenic Denicola: Callbacks, Promises, and Coroutines – Asynchronous Programming Patter in JavaScript</a></li>
+ <li><a href="http://www.mattgreer.org/articles/promises-in-wicked-detail/">Matt Greer: JavaScript Promises ... In Wicked Detail</a></li>
+ <li><a href="https://www.promisejs.org/">Forbes Lindesay: promisejs.org</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/prototype/index.html
new file mode 100644
index 0000000000..a422dd886e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/prototype/index.html
@@ -0,0 +1,113 @@
+---
+title: Promise.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Promise/prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise
+---
+<div>{{JSRef("Global_Objects", "Promise")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A propriedade <code><strong>Promise</strong></code><strong><code>.prototype</code></strong> representa o protótipo para o construtor {{jsxref("Promise")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>{{jsxref("Promise")}} instância herdada de {{jsxref("Promise.prototype")}}. Você pode usar o objeto construtor para adicionar propriedades ou métodos  para todas as instâncias de <code>Promise</code>.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>Promise.prototype.constructor</code></dt>
+ <dd>Retorna a função que cria uma instância. Isso é a função padrão {{jsxref("Promise")}}.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Promise.catch", "Promise.prototype.catch(onRejected)")}}</dt>
+ <dd>Adiciona um callback que trata rejeição para a promise e, retorna uma nova promise resolvendo o valor retornado do callback, se ele for chamado, ou para seu valor original de conclusão se a promise for realizada.</dd>
+ <dt>{{jsxref("Promise.then", "Promise.prototype.then(onFulfilled, onRejected)")}}</dt>
+ <dd>Adiciona os métodos de tratamento da realização e rejeição da promise e, retorna uma nova promise resolvendo para o valor do método chamado.</dd>
+</dl>
+
+<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>{{SpecName('ES6', '#sec-promise.prototype', 'Promise.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>32</td>
+   <td>{{CompatGeckoDesktop(24.0)}} as <code>Future</code><br>
+    {{CompatGeckoDesktop(25.0)}} as <code>Promise</code> behind a flag[1]<br>
+    {{CompatGeckoDesktop(29.0)}} by default</td>
+   <td>{{CompatNo}}</td>
+   <td>19</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(24.0)}} as <code>Future</code><br>
+    {{CompatGeckoMobile(25.0)}} as <code>Promise</code> behind a flag[1]<br>
+    {{CompatGeckoMobile(29.0)}} by default</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>iOS 8</td>
+   <td>32</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Gecko 24 has an experimental implementation of <code>Promise</code>, under the initial name of <code>Future</code>. It got renamed to its final name in Gecko 25, but disabled by default behind the flag <code>dom.promise.enabled</code>. <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918806">Bug 918806</a> enabled Promises by default in Gecko 29.</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/race/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/race/index.html
new file mode 100644
index 0000000000..13a3c659b5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/race/index.html
@@ -0,0 +1,149 @@
+---
+title: Promise.race()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/race
+tags:
+  - ECMAScript6
+  - Experimental
+  - JavaScript
+  - Method
+  - Promise
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/race
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Promise.race(iterable)</strong></code> retorna uma promise que resolve ou rejeita assim que uma das promises no iterável resolver ou rejeitar, com o valor ou razão daquela promise.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>Promise.race(iterable)</var>;</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>iterable</dt>
+ <dd>Um objeto iterável, como um {{jsxref("Array")}}. Veja <a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterável</a>.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função <code>race</code> retorna uma <code>Promise</code> que é estabelecida da mesma forma que a primeira promise passada estabelecer. Ela resolve ou rejeita, o que acontecer primeiro.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Promise.race_–_exemplos_com_setTimeout">Usando <code>Promise.race</code> – exemplos com <code>setTimeout</code></h3>
+
+<pre class="brush: js">var p1 = new Promise(function(resolve, reject) {
+    setTimeout(resolve, 500, "one");
+});
+var p2 = new Promise(function(resolve, reject) {
+    setTimeout(resolve, 100, "two");
+});
+
+Promise.race([p1, p2]).then(function(value) {
+  console.log(value); // "two"
+  // Ambos resolvem, mas p2 é mais rápido
+});
+
+var p3 = new Promise(function(resolve, reject) {
+    setTimeout(resolve, 100, "three");
+});
+var p4 = new Promise(function(resolve, reject) {
+    setTimeout(reject, 500, "four");
+});
+
+Promise.race([p3, p4]).then(function(value) {
+  console.log(value); // "three"
+  // p3 é mais rápido, então ela resolve
+}, function(reason) {
+  // Não é chamado
+});
+
+var p5 = new Promise(function(resolve, reject) {
+    setTimeout(resolve, 500, "five");
+});
+var p6 = new Promise(function(resolve, reject) {
+    setTimeout(reject, 100, "six");
+});
+
+Promise.race([p5, p6]).then(function(value) {
+  // Não é chamado
+}, function(reason) {
+  console.log(reason); // "six"
+  // p6 é mais rápido, então ela rejeita
+});
+</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-promise.race', 'Promise.race')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial em um padrão ECMA.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>32</td>
+   <td>{{CompatGeckoDesktop(29.0)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>19</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(29.0)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+   <td>32</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.html
new file mode 100644
index 0000000000..6097afe484
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/reject/index.html
@@ -0,0 +1,76 @@
+---
+title: Promise.reject()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/reject
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/reject
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Promise.reject(motivo)</strong></code> retorna um objeto Promise que é rejeitada com um dado motivo.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>Promise.reject(motivo)</var>;</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>motivo</dt>
+ <dd>Motivo pelo qual este Promise foi rejeitado.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método estático <code>Promise.reject</code> retorna uma <code>Promise</code> que é rejeitada. Para fins de debug e captura de erros seletiva, é útil que o motivo seja uma <code>instanceof</code> {{jsxref("Error")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_estático_Promise.reject()">Usando o método estático Promise.reject()</h3>
+
+<pre class="brush: js">Promise.reject("Testando reject estático").then(function(motivo) {
+  // não executado
+}, function(motivo) {
+  console.log(motivo); // "Testando reject estático"
+});
+
+Promise.reject(new Error("falha")).then(function(erro) {
+  // não executado
+}, function(erro) {
+  console.log(erro); // Stacktrace
+});</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-promise.reject', 'Promise.reject')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial em um padrão ECMA.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-promise.reject', 'Promise.reject')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.Promise.reject")}}</p>
+
+<p> </p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li><a href="https://github.com/petkaantonov/bluebird#error-handling">Captura de erros seletiva com a biblioteca de Promise BlueBird</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.html
new file mode 100644
index 0000000000..f4c1220158
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/resolve/index.html
@@ -0,0 +1,144 @@
+---
+title: Promise.resolve()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/resolve
+tags:
+  - ECMAScript6
+  - ES6
+  - JavaScript
+  - Método(2)
+  - Promise
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/resolve
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>Promise.resolve(value)</strong></code> retorna um objeto {{jsxref("Promise")}} que é resolvido com o valor passado. Se o valor for <em>thenable</em> (ex: tiver um método {{jsxref("Promise.then", "\"then\"")}}), a promise retornada irá "seguir" esse <em>thenable</em>, adotando seu estado final; se o valor for uma promise, o objeto será o resultado da chamada Promise.resolve; do contrário a promise será realizada com o valor.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>Promise.resolve(value)</var>;
+Promise.resolve(promise);
+Promise.resolve(thenable);
+</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt>value</dt>
+ <dd>Argumento a ser resolvido <font face="Consolas, Liberation Mono, Courier, monospace">pela <code>Promise</code></font>. Pode também ser uma <code>Promise</code> ou um thenable a resolver.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>A {{jsxref("Promise")}} que será resolvida com o valor passado ou com a {{jsxref("Promise")}} passada como valor, caso o valor seja um objeto {{jsxref("Promise")}} </p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função estática <code>Promise.resolve</code> retorna uma <code>Promise</code> de que será resolvida.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Usando_o_método_estático_Promise.resolve">Usando o método estático <code>Promise.resolve</code></h3>
+
+<pre class="brush: js">Promise.resolve("Success").then(function(value) {
+  console.log(value); // "Success"
+}, function(value) {
+  // not called
+});
+</pre>
+
+<h3 id="Resolvendo_um_array">Resolvendo um array</h3>
+
+<pre class="brush: js">var p = Promise.resolve([1,2,3]);
+p.then(function(v) {
+  console.log(v[0]); // 1
+});
+</pre>
+
+<h3 id="Resolvendo_outra_Promise">Resolvendo outra <code>Promise</code></h3>
+
+<pre class="brush: js">var original = Promise.resolve(true);
+var cast = Promise.resolve(original);
+cast.then(function(v) {
+  console.log(v); // true
+});
+
+</pre>
+
+<p>A ordem invertida dos logs acontece devido ao fato de que os handlers são chamados assincronamente. Veja como o <code>then</code> funciona <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then#Return_value">aqui</a>.</p>
+
+<h3 id="Resolvendo_thenables_e_disparando_Errors">Resolvendo thenables e disparando Errors</h3>
+
+<pre class="brush: js">// Resolving a thenable object
+var p1 = Promise.resolve({
+  then: function(onFulfill, onReject) { onFulfill("fulfilled!"); }
+});
+console.log(p1 instanceof Promise) // true, object casted to a Promise
+
+p1.then(function(v) {
+    console.log(v); // "fulfilled!"
+  }, function(e) {
+    // not called
+});
+
+// Thenable throws before callback
+// Promise rejects
+var thenable = { then: function(resolve) {
+  throw new TypeError("Throwing");
+  resolve("Resolving");
+}};
+
+var p2 = Promise.resolve(thenable);
+p2.then(function(v) {
+  // not called
+}, function(e) {
+  console.log(e); // TypeError: Throwing
+});
+
+// Thenable throws after callback
+// Promise resolves
+var thenable = { then: function(resolve) {
+  resolve("Resolving");
+  throw new TypeError("Throwing");
+}};
+
+var p3 = Promise.resolve(thenable);
+p3.then(function(v) {
+  console.log(v); // "Resolving"
+}, function(e) {
+  // not called
+});
+</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-promise.resolve', 'Promise.resolve')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial no padrão ECMA.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-promise.resolve', 'Promise.resolve')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+<p class="hidden">To contribute to this compatibility data, please write a pull request against this file: <a href="https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json">https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json</a>.</p>
+
+<p>{{Compat("javascript.builtins.Promise.resolve")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/promise/then/index.html b/files/pt-br/web/javascript/reference/global_objects/promise/then/index.html
new file mode 100644
index 0000000000..5e3c015947
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/promise/then/index.html
@@ -0,0 +1,181 @@
+---
+title: Promise.prototype.then()
+slug: Web/JavaScript/Reference/Global_Objects/Promise/then
+translation_of: Web/JavaScript/Reference/Global_Objects/Promise/then
+---
+<div>{{JSRef("Global_Objects", "Promise")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <strong>then()</strong> retorna uma <strong>Promise</strong>. Possui dois argumentos, ambos são "<strong>call back functions</strong>", sendo uma para o sucesso e outra para o fracasso da promessa.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>p.then(</var><strong style="font-weight: bold;">quandoRealizada</strong><var>, </var><strong style="font-weight: bold;">quandoRejeitada</strong><var>)</var>;
+
+p.then(function(valor) {
+   // sucesso
+  }, function(motivo) {
+  // rejeitada
+});
+</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt>quandoRealizada</dt>
+ <dd>Uma {{jsxref("Function")}} chamada quando a <strong>Promise</strong> é cumprida (Sucesso). Essa função tem um argumento, o valor do cumprimento.</dd>
+</dl>
+
+<dl>
+ <dt>quandoRejeitada</dt>
+ <dd>Uma {{jsxref("Function")}} chamada quando a Promise é rejeitada. Essa função tem um argumento, o motivo da recusa.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Assim como o método .then()  e {{jsxref("Promise.prototype.catch()")}} retornam uma <strong>Promise</strong>, eles podem ser encadeados - uma operação chamada <em><strong>composition</strong>.</em></p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_then">Usando o método then</h3>
+
+<pre class="brush: js">var p1 = new Promise(function(resolve, reject) {
+  resolve("Success!");
+  // or
+  // reject ("Error!");
+});
+
+p1.then(function(value) {
+  console.log(value); // Success!
+}, function(reason) {
+  console.log(reason); // Error!
+});
+</pre>
+
+<h3 id="Encadeando">Encadeando</h3>
+
+<p>Já que o método then() devolve uma <strong>Promise</strong>, você pode facilmente encadeá-los. </p>
+
+<pre class="brush: js">var p2 = new Promise(function(resolve, reject) {
+  resolve(1);
+});
+
+p2.then(function(value) {
+  console.log(value); // 1
+  return value + 1;
+}).then(function(value) {
+  console.log(value); // 2
+});
+
+</pre>
+
+<p>No exemplo acima, o último <strong>.then()</strong> recebeu a soma value + 1, que resultou em 2, porém se o retorno de value + 1 fosse uma <strong>Promise</strong> que também retornasse value + 1, o resultado seria o mesmo. Note, no exemplo abaixo, que leva 1000ms para a impressão de 2 ocorrer.</p>
+
+<pre class="brush: js">var p2 = new Promise(function(resolve, reject) {
+   resolve(1);
+});
+
+p2.then(function(value) {
+  console.log(value); // 1
+  return new Promise(function (resolve, reject) {
+    setTimeout(function () {
+      resolve(value + 1);
+    }, 1000);
+  });
+}).then(function(value) {
+  console.log(value); // 2
+});</pre>
+
+<p> </p>
+
+<p> </p>
+
+<h2 id="sect1"> </h2>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td><a href="https://github.com/domenic/promises-unwrapping">domenic/promises-unwrapping</a></td>
+   <td>Draft</td>
+   <td>Standardization work is taking place here.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-promise.prototype.then', 'Promise.prototype.then')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition in an ECMA standard.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_Browsers">Compatibilidade dos Browsers</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>32</td>
+   <td>{{CompatGeckoDesktop(24.0)}} as <code>Future</code><br>
+    {{CompatGeckoDesktop(25.0)}} as <code>Promise</code> behind a flag[1]<br>
+    {{CompatGeckoDesktop(29.0)}} by default</td>
+   <td>{{CompatNo}}</td>
+   <td>19</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(24.0)}} as <code>Future</code><br>
+    {{CompatGeckoMobile(25.0)}} as <code>Promise</code> behind a flag[1]<br>
+    {{CompatGeckoMobile(29.0)}} by default</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>iOS 8</td>
+   <td>32</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Gecko 24 possui uma implementação experimental de Promise, under the initial name of <code>Future</code>. It got renamed to its final name in Gecko 25, but disabled by default behind the flag <code>dom.promise.enabled</code>. <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918806">Bug 918806</a> enabled Promises by default in Gecko 29.</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Promise")}}</li>
+ <li>{{jsxref("Promise.prototype.catch()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/proxy/index.html b/files/pt-br/web/javascript/reference/global_objects/proxy/index.html
new file mode 100644
index 0000000000..2975088492
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/proxy/index.html
@@ -0,0 +1,396 @@
+---
+title: Proxy
+slug: Web/JavaScript/Reference/Global_Objects/Proxy
+translation_of: Web/JavaScript/Reference/Global_Objects/Proxy
+---
+<div>
+<div>{{JSRef}}</div>
+</div>
+
+<p>O objeto <strong>Proxy</strong> é usado para definir comportamentos customizados para operações fundamentais (por exemplo, pesquisa de propriedade, atribuição, enumeração, invocação de função, etc.).</p>
+
+<h2 id="Terminologia">Terminologia</h2>
+
+<dl>
+ <dt><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler">handler</a></dt>
+ <dd>Objeto marcador que contém <em>traps</em>.</dd>
+ <dt>traps</dt>
+ <dd>Métodos que fornecem acesso à propriedade. Isto é análogo ao conceito de <em>traps </em>(armadilhas) em sistemas operacionais</dd>
+ <dt>target</dt>
+ <dd>Objeto que o proxy virtualiza. É frequentemente utilizado como back-end de armazenamento para o proxy. Os invariantes (semânticas que permanecem inalterados) em relação à não-extensibilidade do objeto ou propriedades não-configuráveis são verificados em relação ao <em>target</em>.</dd>
+</dl>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">var p = new Proxy(target, handler);
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>target</code></dt>
+ <dd>Um objeto target (pode ser qualquer tipo de objeto, incluindo um array, uma função ou até mesmo outro <em>Proxy</em>) a ser envolvido com o <code>Proxy</code>.</dd>
+ <dt><code>handler</code></dt>
+ <dd>Um objeto cujas propriedades são funções que definem o comportamento do proxy quando uma operação é realizada sobre ele.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Proxy.revocable()")}}</dt>
+ <dd>Cria um objeto <code> Proxy </code> revogável.</dd>
+</dl>
+
+<h2 id="Métodos_para_manipular_objetos">Métodos para manipular objetos</h2>
+
+<p>O objeto manipulado é um objeto reservado que contém traps para <code> Proxy. </code></p>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler', 'Methods') }}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_básico">Exemplo básico</h3>
+
+<p>Neste exemplo simples, o número <code> 37 </code> é retornado como o valor padrão quando o nome da propriedade não está no objeto. Usa-se o manipulador <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/get"><code>get</code></a>.</p>
+
+<pre class="brush: js">var handler = {
+    get: function(target, name) {
+        return name in target ?
+            target[name] :
+            37;
+    }
+};
+
+var p = new Proxy({}, handler);
+p.a = 1;
+p.b = undefined;
+
+console.log(p.a, p.b); // 1, undefined
+console.log('c' in p, p.c); // false, 37
+</pre>
+
+<h3 id="Encaminhamento_de_Proxy">Encaminhamento de Proxy</h3>
+
+<p>Neste exemplo, estamos usando um objeto JavaScript nativo ao qual nosso proxy irá encaminhar todas as operações que são aplicadas para ele.</p>
+
+<pre class="brush: js">var target = {};
+var p = new Proxy(target, {});
+
+p.a = 37; // Operação encaminhada para o alvo
+
+console.log(target.a); // 37. A operação foi devidamente encaminhada
+</pre>
+
+<h3 id="Validação">Validação</h3>
+
+<p>Com um <code> Proxy</code>, você pode validar facilmente o valor passado para um objeto. Este exemplo usa o manipulador <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"> <code> set</code></a>.</p>
+
+<pre class="brush: js">let validator = {
+  set: function(obj, prop, value) {
+    if (prop === 'age') {
+      if (!Number.isInteger(value)) {
+        throw new TypeError('The age is not an integer');
+      }
+      if (value &gt; 200) {
+        throw new RangeError('The age seems invalid');
+      }
+    }
+
+    //O comportamento padrão para armazenar o valor
+    obj[prop] = value;
+
+    // Indique o sucesso
+    return true;
+  }
+};
+
+let person = new Proxy({}, validator);
+
+person.age = 100;
+console.log(person.age); // 100
+person.age = 'young'; // Lança uma exceção
+person.age = 300; // Lança uma exceção</pre>
+
+<h3 id="Construtor_de_extensão">Construtor de extensão</h3>
+
+<p>Um proxy de função poderia facilmente estender um construtor com um novo construtor. Este exemplo usa os manipuladores <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/construct"> <code> construct </code> </a> e <a href="/En-US/docs/Web/JavaScript/Referência/Global_Objects/Proxy/handler/apply"> <code> apply</code></a>.</p>
+
+<pre class="brush: js">function extend(sup, base) {
+  var descriptor = Object.getOwnPropertyDescriptor(
+    base.prototype, 'constructor'
+  );
+  base.prototype = Object.create(sup.prototype);
+  var handler = {
+    construct: function(target, args) {
+      var obj = Object.create(base.prototype);
+      this.apply(target, obj, args);
+      return obj;
+    },
+    apply: function(target, that, args) {
+      sup.apply(that, args);
+      base.apply(that, args);
+    }
+  };
+  var proxy = new Proxy(base, handler);
+  descriptor.value = proxy;
+  Object.defineProperty(base.prototype, 'constructor', descriptor);
+  return proxy;
+}
+
+var Person = function(name) {
+  this.name = name;
+};
+
+var Boy = extend(Person, function(name, age) {
+  this.age = age;
+});
+
+Boy.prototype.sex = 'M';
+
+var Peter = new Boy('Peter', 13);
+console.log(Peter.sex);  // "M"
+console.log(Peter.name); // "Peter"
+console.log(Peter.age);  // 13</pre>
+
+<h3 id="DOM_manipulação_de_nós">DOM manipulação de nós</h3>
+
+<p>Às vezes, você deseja alternar o atributo ou o nome da classe de dois elementos diferentes. Veja como usar o manipulador <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/set"> <code> set</code></a>.</p>
+
+<pre class="brush: js">let view = new Proxy({
+  selected: null
+},
+{
+  set: function(obj, prop, newval) {
+    let oldval = obj[prop];
+
+    if (prop === 'selected') {
+      if (oldval) {
+        oldval.setAttribute('aria-selected', 'false');
+      }
+      if (newval) {
+        newval.setAttribute('aria-selected', 'true');
+      }
+    }
+
+    // O comportamento para armazenar o valor padrão
+    obj[prop] = newval;
+
+    // Indica o sucesso
+    return true;
+  }
+});
+
+let i1 = view.selected = document.getElementById('item-1');
+console.log(i1.getAttribute('aria-selected')); // 'true'
+
+let i2 = view.selected = document.getElementById('item-2');
+console.log(i1.getAttribute('aria-selected')); // 'false'
+console.log(i2.getAttribute('aria-selected')); // 'true'</pre>
+
+<h3 id="Correção_de_valor_e_uma_propriedade_extra">Correção de valor e uma propriedade extra</h3>
+
+<p>O objeto de proxy <code> produtos </code> avalia o valor passado e converte-o em uma matriz, se necessário. O objeto também suporta uma propriedade adicional chamada <code> latestBrowser </code> tanto em getters como em setters.</p>
+
+<pre class="brush: js">let products = new Proxy({
+  browsers: ['Internet Explorer', 'Netscape']
+},
+{
+  get: function(obj, prop) {
+    // An extra property
+    if (prop === 'latestBrowser') {
+      return obj.browsers[obj.browsers.length - 1];
+    }
+
+    //  O comportamento para armazenar o valor padrão
+    return obj[prop];
+  },
+  set: function(obj, prop, value) {
+    // An extra property
+    if (prop === 'latestBrowser') {
+      obj.browsers.push(value);
+      return true;
+    }
+
+    // Converta o valor se não for uma matriz
+    if (typeof value === 'string') {
+      value = [value];
+    }
+
+    //  O comportamento para armazenar o valor padrão
+    obj[prop] = value;
+
+    // Indicate success
+    return true;
+  }
+});
+
+console.log(products.browsers); // ['Internet Explorer', 'Netscape']
+products.browsers = 'Firefox'; // pass a string (by mistake)
+console.log(products.browsers); // ['Firefox'] &lt;- no problem, the value is an array
+
+products.latestBrowser = 'Chrome';
+console.log(products.browsers); // ['Firefox', 'Chrome']
+console.log(products.latestBrowser); // 'Chrome'</pre>
+
+<h3 id="Encontrando_um_item_de_objeto_em_uma_matriz_por_propriedade">Encontrando um item de objeto em uma matriz por propriedade</h3>
+
+<p>Esta proxy estende uma matriz com alguns recursos de utilidade. Como você vê, você pode "definir" propriedades flexíveis sem usar <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperties"> <code> Object.defineProperties</code></a>. Este exemplo pode ser adaptado para encontrar uma linha de tabela por sua célula. Nesse caso, o alvo será <a href="/en-US/docs/DOM/table.rows"> <code> table.rows </code> </a></p>
+
+<pre class="brush: js">let products = new Proxy([
+  { name: 'Firefox', type: 'browser' },
+  { name: 'SeaMonkey', type: 'browser' },
+  { name: 'Thunderbird', type: 'mailer' }
+],
+{
+  get: function(obj, prop) {
+    // O comportamento para retornar o valor; Prop geralmente é um inteiro
+    if (prop in obj) {
+      return obj[prop];
+    }
+
+    // Obter o número de produtos; Com products.length
+    if (prop === 'number') {
+      return obj.length;
+    }
+
+    let result, types = {};
+
+    for (let product of obj) {
+      if (product.name === prop) {
+        result = product;
+      }
+      if (types[product.type]) {
+        types[product.type].push(product);
+      } else {
+        types[product.type] = [product];
+      }
+    }
+
+    // Obtém um produto por nome
+    if (result) {
+      return result;
+    }
+
+    // Obtém produtos por tipo
+    if (prop in types) {
+      return types[prop];
+    }
+
+    // Obtém tipos de produto
+    if (prop === 'types') {
+      return Object.keys(types);
+    }
+
+    return undefined;
+  }
+});
+
+console.log(products[0]); // { name: 'Firefox', type: 'browser' }
+console.log(products['Firefox']); // { name: 'Firefox', type: 'browser' }
+console.log(products['Chrome']); // undefined
+console.log(products.browser); // [{ name: 'Firefox', type: 'browser' }, { name: 'SeaMonkey', type: 'browser' }]
+console.log(products.types); // ['browser', 'mailer']
+console.log(products.number); // 3</pre>
+
+<h3 id="Um_exemplo_completo_de_lista_de_traps">Um exemplo completo de lista de <code>traps</code></h3>
+
+<p>Agora, para criar uma lista completa de amostra de <code>traps</code>, para fins didáticos, tentaremos propor um objeto <em>não nativo</em> que seja particularmente adequado para este tipo de operação: o objeto global <code>docCookies</code> criado por <a href="https://developer.mozilla.org/en-US/docs/Web/API/Document/cookie/Simple_document.cookie_framework" title="https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support"> a "little framework" publicada na página<code>document.cookie</code></a>.</p>
+
+<pre class="brush: js">/*
+  var docCookies = ... get the "docCookies" object here:
+  https://developer.mozilla.org/en-US/docs/DOM/document.cookie#A_little_framework.3A_a_complete_cookies_reader.2Fwriter_with_full_unicode_support
+*/
+
+var docCookies = new Proxy(docCookies, {
+  get: function (oTarget, sKey) {
+    return oTarget[sKey] || oTarget.getItem(sKey) || undefined;
+  },
+  set: function (oTarget, sKey, vValue) {
+    if (sKey in oTarget) { return false; }
+    return oTarget.setItem(sKey, vValue);
+  },
+  deleteProperty: function (oTarget, sKey) {
+    if (sKey in oTarget) { return false; }
+    return oTarget.removeItem(sKey);
+  },
+  enumerate: function (oTarget, sKey) {
+    return oTarget.keys();
+  },
+  ownKeys: function (oTarget, sKey) {
+    return oTarget.keys();
+  },
+  has: function (oTarget, sKey) {
+    return sKey in oTarget || oTarget.hasItem(sKey);
+  },
+  defineProperty: function (oTarget, sKey, oDesc) {
+    if (oDesc &amp;&amp; 'value' in oDesc) { oTarget.setItem(sKey, oDesc.value); }
+    return oTarget;
+  },
+  getOwnPropertyDescriptor: function (oTarget, sKey) {
+    var vValue = oTarget.getItem(sKey);
+    return vValue ? {
+      value: vValue,
+      writable: true,
+      enumerable: true,
+      configurable: false
+    } : undefined;
+  },
+});
+
+/* Teste Cookies */
+
+console.log(docCookies.my_cookie1 = 'First value');
+console.log(docCookies.getItem('my_cookie1'));
+
+docCookies.setItem('my_cookie1', 'Changed value');
+console.log(docCookies.my_cookie1);</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-proxy-objects', 'Proxy')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição Inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-proxy-objects', 'Proxy')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>?</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_Compatíveis">Navegadores Compatíveis</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Proxy", 2)}}</p>
+
+<h2 id="Notas_Especificas_Gecko">Notas Especificas Gecko</h2>
+
+<ul>
+ <li>No momento, <code>Object.getPrototypeOf(proxy)</code> retorna incondicionalmente um <code>Object.getPrototypeOf(target)</code>, porque a trap ES2015 getPrototypeOf não foi implementada ({{bug(795904)}}, {{bug(888969)}}).</li>
+ <li><code>Array.isArray(proxy)</code> retorna incondicionalmente um <code>Array.isArray(target)</code> ({{bug(1096753)}}, {{bug(1111785)}}).</li>
+ <li><code>Object.prototype.toString.call(proxy)</code> retorna incondicionalmente <code>Object.prototype.toString.call(target)</code>, porque ES2015 Symbol.toStringTag não foi implementado ({{bug(1114580)}}).</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a class="external" href="https://www.youtube.com/watch?v=sClk6aB_CPk">"Proxies are awesome" Brendan Eich presentation at JSConf</a> (<a class="external" href="http://www.slideshare.net/BrendanEich/metaprog-5303821">slides</a>)</li>
+ <li><a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies">ECMAScript Harmony Proxy proposal page</a> e <a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:proxies_semantics">ECMAScript página de semântica de proxy Harmony</a></li>
+ <li><a class="external" href="http://soft.vub.ac.be/~tvcutsem/proxies/">Tutorial em proxies</a></li>
+ <li><a href="/en-US/docs/JavaScript/Old_Proxy_API" title="/en-US/docs/JavaScript/Old_Proxy_API">SpiderMonkey specific Old Proxy API</a></li>
+ <li>{{jsxref("Object.watch()")}} É um recurso não padrão, mas foi suportado no Gecko há muito tempo.</li>
+</ul>
+
+<h2 id="Nota_de_licença"><code><code>Nota de licença</code></code></h2>
+
+<p>Alguns conteúdos (texto, exemplos) nesta página foram copiados ou adaptados do <a class="external" href="http://wiki.ecmascript.org/doku.php"> ECMAScript wiki </a> que contém à licença de conteúdo <a class="external" href="http://creativecommons.org/licenses/by-nc-sa/2.0/"> CC 2.0 BY-NC-SA </a>.</p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.html b/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.html
new file mode 100644
index 0000000000..5a00314c2c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/referenceerror/index.html
@@ -0,0 +1,171 @@
+---
+title: ReferenceError
+slug: Web/JavaScript/Reference/Global_Objects/ReferenceError
+translation_of: Web/JavaScript/Reference/Global_Objects/ReferenceError
+---
+<div>{{JSRef}}</div>
+
+<p>O objeto <code><strong>ReferenceError</strong></code> representa um erro quando uma variável não existente é referenciada.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>new ReferenceError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>message</code></dt>
+ <dd>Opcional. Descrição legível do erro.</dd>
+ <dt><code>fileName</code> {{non-standard_inline}}</dt>
+ <dd>Opcional. O nome do arquivo contendo o código que causou a excessão.</dd>
+ <dt><code>lineNumber</code> {{non-standard_inline}}</dt>
+ <dd>Opcional. O número da linha do código que causou a excessão.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O  <code>ReferenceError</code> acontece quando é feita uma tentativa de referenciar uma variável que não foi declarada.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("ReferenceError.prototype")}}</dt>
+ <dd>Permite a inclusão de propriedades em um objeto <code>ReferenceError</code>.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<p>O <code>ReferenceError</code> não contém métodos próprios, porém, ele herda alguns métodos através da cadeia de protótipos.</p>
+
+<h2 id="Instâncias_do_ReferenceError">Instâncias do <code>ReferenceError</code> </h2>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype', 'Properties')}}</div>
+
+<h3 id="Métodos_2">Métodos</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError/prototype', 'Methods')}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Capturando_um_ReferenceError">Capturando um <code>ReferenceError</code></h3>
+
+<pre class="brush: js">try {
+  var a = variavelNaoDefinida;
+} catch (e) {
+  console.log(e instanceof ReferenceError); // true
+  console.log(e.message);                   // "variavelNaoDefinida não está definida"
+  console.log(e.name);                      // "ReferenceError"
+  console.log(e.fileName);                  // "Scratchpad/1"
+  console.log(e.lineNumber);                // 2
+  console.log(e.columnNumber);              // 6
+  console.log(e.stack);                     // "@Scratchpad/2:2:7\n"
+}
+</pre>
+
+<h3 id="Criando_um_ReferenceError">Criando um <code>ReferenceError</code></h3>
+
+<pre class="brush: js">try {
+  throw new ReferenceError('Olá', 'arquivoQualquer.js', 10);
+} catch (e) {
+  console.log(e instanceof ReferenceError); // true
+  console.log(e.message);                   // "Olá"
+  console.log(e.name);                      // "ReferenceError"
+  console.log(e.fileName);                  // "arquivoQualquer.js"
+  console.log(e.lineNumber);                // 10
+  console.log(e.columnNumber);              // 0
+  console.log(e.stack);                     // "@Scratchpad/2:2:9\n"
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.6.3', 'ReferenceError')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-referenceerror', 'ReferenceError')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-native-error-types-used-in-this-standard-referenceerror', 'ReferenceError')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Error")}}</li>
+ <li>{{jsxref("ReferenceError.prototype")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.html
new file mode 100644
index 0000000000..08621fe798
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/apply/index.html
@@ -0,0 +1,143 @@
+---
+title: Reflect.apply()
+slug: Web/JavaScript/Reference/Global_Objects/Reflect/apply
+tags:
+  - ECMAScript6
+  - JavaScript
+  - Reflect
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/apply
+---
+<div>{{JSRef}}</div>
+
+<p>O método estático <code><strong>Reflect</strong></code><strong><code>.apply()</code></strong> chama uma função alvo com os argumentos especificados.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Reflect.apply(target, thisArgument, argumentsList)
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>target</dt>
+ <dd>Função que será chamada.</dd>
+ <dt>thisArgument</dt>
+ <dd>O valor de "<code>this"</code> que será usado pela function do target.</dd>
+ <dt>argumentsList</dt>
+ <dd>Um objeto do tipo array que especifica os argumentos com que o <em><code>target</code></em> deve ser chamado.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O resultado da função alvo chamada com o <code><strong>this</strong></code>  e argumentos especificados.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<p>Um {{jsxref("TypeError")}}, se a função especificada no <em>target</em> não for invocável.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>No ES5, tipicamente é usado o método {{jsxref("Function.prototype.apply()")}} para chamar uma função com o valor de <code>this e argumentos</code> <font face="Consolas, Liberation Mono, Courier, monospace">fornecidos como um array</font> (ou um <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">array-like object</a>).</p>
+
+<pre class="brush: js">Function.prototype.apply.call(Math.floor, undefined, [1.75]);</pre>
+
+<p>Com o <code>Reflect.apply</code> isso se torna menos verboso e mais fácil de entender.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Reflect.apply()">Usando <code>Reflect.apply()</code></h3>
+
+<pre class="brush: js">Reflect.apply(Math.floor, undefined, [1.75]);
+// 1;
+
+Reflect.apply(String.fromCharCode, undefined, [104, 101, 108, 108, 111]);
+// "hello"
+
+Reflect.apply(RegExp.prototype.exec, /ab/, ["confabulation"]).index;
+// 4
+
+Reflect.apply("".charAt, "ponies", [3]);
+// "i"
+</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-reflect.apply', 'Reflect.apply')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-reflect.apply', 'Reflect.apply')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>49</td>
+   <td>{{CompatGeckoDesktop(42)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(42)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Reflect")}}</li>
+ <li>{{jsxref("Function.prototype.apply()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.html
new file mode 100644
index 0000000000..dece94c79a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/construct/index.html
@@ -0,0 +1,151 @@
+---
+title: Reflect.construct()
+slug: Web/JavaScript/Reference/Global_Objects/Reflect/construct
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/construct
+---
+<div>{{JSRef}}</div>
+
+<p>The static <code><strong>Reflect</strong></code><strong><code>.construct()</code></strong> method acts like the <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code> operator</a>, but as a function. It is equivalent to calling <code>new target(...args)</code>. It gives also the added option to specify a different prototype.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/reflect-construct.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Reflect.construct(target, argumentsList[, newTarget])
+</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>target</code></dt>
+ <dd>A função alvo à ser chamada.</dd>
+ <dt><code>argumentsList</code></dt>
+ <dd>Um objeto tipo array que especifica com quais argumentos <code>target</code> deveria ser chamada.</dd>
+ <dt><code>newTarget</code> {{optional_inline}}</dt>
+ <dd>O construtor de quem o protótipo deveria ser usado. Veja também o <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a></code> operador. Se <code>newTarget</code> não estiver presente, será <code>target</code>.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>A new instance of <code>target</code> (or <code>newTarget</code>, if present), initialized by <code>target</code> as a constructor with the given arguments.</p>
+
+<h3 id="Exceptions">Exceptions</h3>
+
+<p>A {{jsxref("TypeError")}}, if <code>target</code> or <code>newTarget</code> are not constructors.</p>
+
+<h2 id="Description">Description</h2>
+
+<p><code>Reflect.construct</code> allows you to invoke a constructor with a variable number of arguments (which would also be possible by using the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a> combined with the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new operator</a>).</p>
+
+<pre class="brush: js">var obj = new Foo(...args);
+var obj = Reflect.construct(Foo, args);
+</pre>
+
+<p> </p>
+
+<h3 id="Reflect.construct()_vs_Object.create()"><code>Reflect.construct()</code> vs <code>Object.create()</code></h3>
+
+<p>Prior to the introduction of <code>Reflect</code>, objects could be constructed using an arbitrary combination of constructor and prototype by using <code>Object.create()</code>.</p>
+
+<pre class="brush: js">function OneClass() {
+    this.name = 'one';
+}
+
+function OtherClass() {
+    this.name = 'other';
+}
+
+// Calling this:
+var obj1 = Reflect.construct(OneClass, args, OtherClass);
+
+// ...has the same result as this:
+var obj2 = Object.create(OtherClass.prototype);
+OneClass.apply(obj2, args);
+
+console.log(obj1.name); // 'one'
+console.log(obj2.name); // 'one'
+
+console.log(obj1 instanceof OneClass); // false
+console.log(obj2 instanceof OneClass); // false
+
+console.log(obj1 instanceof OtherClass); // true
+console.log(obj2 instanceof OtherClass); // true
+</pre>
+
+<p>However, while the end result is the same, there is one important difference in the process. When using <code>Object.create()</code> and <code>Function.prototype.apply()</code>, the <code>new.target</code> operator will point to <code>undefined</code> within the function used as the constructor, since the <code>new</code> keyword is not being used to create the object.</p>
+
+<p>When invoking <code>Reflect.construct()</code>, on the other hand, the <code>new.target</code> operator will point to the <code>newTarget</code> parameter if supplied, or <code>target</code> if not.</p>
+
+<pre class="brush: js">function OneClass() {
+    console.log('OneClass');
+    console.log(new.target);
+}
+function OtherClass() {
+    console.log('OtherClass');
+    console.log(new.target);
+}
+
+var obj1 = Reflect.construct(OneClass, args);
+// Output:
+//     OneClass
+//     function OneClass { ... }
+
+var obj2 = Reflect.construct(OneClass, args, OtherClass);
+// Output:
+//     OneClass
+//     function OtherClass { ... }
+
+var obj3 = Object.create(OtherClass.prototype);
+OneClass.apply(obj3, args);
+// Output:
+//     OneClass
+//     undefined</pre>
+
+<p> </p>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Using_Reflect.construct()">Using <code>Reflect.construct()</code></h3>
+
+<pre class="brush: js">var d = Reflect.construct(Date, [1776, 6, 4]);
+d instanceof Date; // true
+d.getFullYear(); // 1776
+</pre>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES2015', '#sec-reflect.construct', 'Reflect.construct')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-reflect.construct', 'Reflect.construct')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Reflect.construct")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("Reflect")}}</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/new"><code>new</code></a></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new.target">new.target</a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.html
new file mode 100644
index 0000000000..c4b56f02ca
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/defineproperty/index.html
@@ -0,0 +1,97 @@
+---
+title: Reflect.defineProperty()
+slug: Web/JavaScript/Reference/Global_Objects/Reflect/defineProperty
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Referencia
+  - Reflect
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/defineProperty
+---
+<div>{{JSRef}}</div>
+
+<p>O método estático <code><strong>Reflect</strong></code><strong><code>.defineProperty()</code></strong> é como o {{jsxref("Object.defineProperty()")}}, mas retorna um {{jsxref("Boolean")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/reflect-defineproperty.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">Reflect.defineProperty(<var>target</var>, <var>propertyKey</var>, <var>attributes</var>)
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>target</var></code></dt>
+ <dd>O objeto de destino onde será definida a propriedade.</dd>
+ <dt><code><var>propertyKey</var></code></dt>
+ <dd>O nome da propriedade a ser definida ou modificada.</dd>
+ <dt><code><var>attributes</var></code></dt>
+ <dd>Os atributos para a propriedade que está sendo definida ou modificada.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se a propriedade foi ou não definida com êxito.</p>
+
+<h3 id="Erros">Erros</h3>
+
+<p>Um {{jsxref("TypeError")}}, se <code><var>target</var></code> não for um {{jsxref("Object")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Reflect.defineProperty</code> permite a adição precisa ou a modificação de uma propriedade em um objeto. Para mais detalhes veja o {{jsxref("Object.defineProperty")}}, que é semelhante.</p>
+
+<div class="blockIndicator note">
+<p><strong>Uma diferença fundamental:</strong> <code>Object.defineProperty</code> retorna o objeto ou lança um {{jsxref ("TypeError")}} se a propriedade não tiver sido definida com êxito. <code>Reflect.defineProperty</code>, no entanto, simplesmente retorna um {{jsxref ("Boolean")}} indicando se a propriedade foi ou não definida com êxito.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Reflect.defineProperty">Usando <code>Reflect.defineProperty()</code></h3>
+
+<pre class="brush: js notranslate">let obj = {}
+Reflect.defineProperty(obj, 'x', {value: 7})  // true
+obj.x                                         // 7
+</pre>
+
+<h3 id="Verificando_se_a_definição_da_propriedade_foi_bem-sucedida">Verificando se a definição da propriedade foi bem-sucedida</h3>
+
+<p>Com o {{jsxref ("Object.defineProperty")}}, que retorna um objeto se for bem-sucedido ou lança um {{jsxref ("TypeError")}}, você usaria um bloco <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/try...catch">try...catch</a> para detectar qualquer erro que ocorreu ao definir uma propriedade.</p>
+
+<p>Como <code>Reflect.defineProperty</code> retorna um status de sucesso booleano, você pode usar apenas um bloco <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else">if...else</a></code> aqui:</p>
+
+<pre class="brush: js notranslate">if (Reflect.defineProperty(target, property, attributes)) {
+  // success
+} else {
+  // failure
+}</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-reflect.defineproperty', 'Reflect.defineProperty')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Reflect.defineProperty")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Reflect")}}</li>
+ <li>{{jsxref("Object.defineProperty()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/index.html
new file mode 100644
index 0000000000..e001709367
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/index.html
@@ -0,0 +1,166 @@
+---
+title: Reflect
+slug: Web/JavaScript/Reference/Global_Objects/Reflect
+tags:
+  - ECMAScript6
+  - JavaScript
+  - NeedsTranslation
+  - Overview
+  - Reflect
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect
+---
+<div>{{JSRef}}</div>
+
+<p><strong>Reflect</strong> é um objeto nativo que provê métodos para operações JavaScript interceptáveis. Os métodos são os mesmos que o dos <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Proxy">manipuladores de Proxy</a>. <code>Reflect</code> não é um objeto de função, então não é construtível.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Ao contrário da maioria dos objetos globais, <code>Reflect</code> não é um construtor. Você não pode usá-lo com o <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/new">operador new</a> ou invocar o objeto <code>Reflect</code> como uma função. Todas as propriedades e métodos do <code>Reflect</code> são estáticos (igual o objeto {{jsxref("Math")}}).</p>
+
+<p>O objeto <code>Reflect</code> provê as seguintes funções estáticas as quais tem os mesmos nomes usados pelos métodos <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Proxy">manipuladores de Proxy</a>.</p>
+
+<p>Alguns deste métodos são também os mesmos correspondentes aos métodos em {{jsxref("Object")}}, embora eles tenham diferenças sutis entre eles.</p>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Reflect.apply()", "Reflect.apply(<var>target</var>, <var>thisArgument</var>, <var>argumentsList</var>)")}}</dt>
+ <dd>Chama uma função de destino com os argumentos, conforme especificado pelo parâmetro <em><code>argumentsList</code></em>. Veja também {{jsxref("Function.prototype.apply()")}}.</dd>
+ <dt>{{jsxref("Reflect.construct()", "Reflect.construct(<var>target</var>, <var>argumentsList</var>[, <var>newTarget</var>])")}}</dt>
+ <dd> O <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/new">operador new</a> como uma função. Equivalente a chamada <code>new target(...args)</code>. Também possui a opção de especificar um <code><em>prototype</em></code> diferente</dd>
+ <dt>{{jsxref("Reflect.defineProperty()", "Reflect.defineProperty(<var>target</var>, <var>propertyKey</var>, <var>attributes</var>)")}}</dt>
+ <dd>Similar ao {{jsxref("Object.defineProperty()")}}. Retorna um {{jsxref("Boolean")}} com o valor <code>true</code><em> se a propriedade foi definida com sucesso</em>.</dd>
+ <dt>{{jsxref("Reflect.deleteProperty()", "Reflect.deleteProperty(<var>target</var>, <var>propertyKey</var>)")}}</dt>
+ <dd>O <a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">operador delete</a> como uma função. Equivalente a chamada <code>delete target[name]</code>.</dd>
+ <dt>{{jsxref("Reflect.get()")}}, "Reflect.get(<var>target</var>, <var>propertyKey</var>[, <var>receiver</var>])"}}</dt>
+ <dd>Uma função que retorna o valor da propriedade. Funciona como obter uma propriedade de um objeto (<code>target[propertyKey]</code>) como uma função.</dd>
+ <dt>{{jsxref("Reflect.getOwnPropertyDescriptor()", "Reflect.getOwnPropertyDescriptor(<var>target</var>, <var>propertyKey</var>)")}}</dt>
+ <dd>Similar ao {{jsxref("Object.getOwnPropertyDescriptor()")}}. Retorna um descritor de propriedade da propriedade dada se existir no objeto, {{jsxref ("undefined")}} caso contrário.</dd>
+ <dt>{{jsxref("Reflect.getPrototypeOf()", "Reflect.getPrototypeOf(<var>target</var>)")}}</dt>
+ <dd>Igual ao {{jsxref("Object.getPrototypeOf()")}}.</dd>
+ <dt>{{jsxref("Reflect.has()", "Reflect.has(<var>target, propertyKey</var>)")}}</dt>
+ <dd>O <a href="/en-US/docs/Web/JavaScript/Reference/Operators/in">operador in</a> como função. Retorna um {{jsxref("Boolean")}} indicando se existe uma propriedade própria ou herdada.</dd>
+ <dt>{{jsxref("Reflect.isExtensible()", "Reflect.isExtensible(<var>target</var>)")}}</dt>
+ <dd>Igual ao {{jsxref("Object.isExtensible()")}}. Returna um {{jsxref("Boolean")}} com o valor <code>true</code> se o destino (parâmetro target) for extensível.</dd>
+ <dt>{{jsxref("Reflect.ownKeys()", "Reflect.ownKeys(<var>target</var>)")}}</dt>
+ <dd>Retorna uma matriz das chaves de propriedade do próprio objeto de destino (não herdadas).</dd>
+ <dt>{{jsxref("Reflect.preventExtensions()", "Reflect.preventExtensions(<var>target</var>)")}}</dt>
+ <dd>Similar ao {{jsxref("Object.preventExtensions()")}}. Retorna um {{jsxref("Boolean")}} com o valor <code>true</code> se a atualização foi bem sucedida.</dd>
+ <dt>{{jsxref("Reflect.set()", "Reflect.set(<var>target</var>, <var>propertyKey</var>, <var>value</var>[, <var>receiver</var>])")}}</dt>
+ <dd>Uma função que atribui valores a propriedades. Retorna um {{jsxref ("Boolean")}} com o valor <code>true</code> se a atualização foi bem sucedida.</dd>
+ <dt>{{jsxref("Reflect.setPrototypeOf()", "Reflect.setPrototypeOf(<var>target</var>, <var>prototype</var>)")}}</dt>
+ <dd>Uma função que define o <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype">protótipo de um objeto</a>. Retorna um {{jsxref ("Boolean")}} com o valor <code>true</code> se a atualização foi bem sucedida.</dd>
+ <dt>
+ <h2 id="Exemplos">Exemplos</h2>
+
+ <h3 id="Verificando_se_um_objeto_contém_determinadas_propriedades">Verificando se um objeto contém determinadas propriedades</h3>
+
+ <pre class="brush: js notranslate">const duck = {
+  name: 'Maurice',
+  color: 'white',
+  greeting: function() {
+    console.log(`Quaaaack! My name is ${this.name}`);
+  }
+}
+
+Reflect.has(duck, 'color');
+// true
+Reflect.has(duck, 'haircut');
+// false</pre>
+
+ <h3 id="Retornando_as_próprias_chaves_do_objeto">Retornando as próprias chaves do objeto</h3>
+
+ <pre class="brush: js notranslate">Reflect.ownKeys(duck);
+// [ "name", "color", "greeting" ]</pre>
+
+ <h3 id="Adicionando_uma_nova_propriedade_ao_objeto">Adicionando uma nova propriedade ao objeto</h3>
+
+ <pre class="brush: js notranslate">Reflect.set(duck, 'eyes', 'black');
+// returns "true" if successful
+// "duck" now contains the property "eyes: 'black'"</pre>
+ </dt>
+</dl>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-reflect-object', 'Reflect')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição Inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-reflect-object', 'Reflect')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Reflect.enumerate foi removido.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("42")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{CompatGeckoMobile("42")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>The {{jsxref("Proxy")}} global object.</li>
+ <li>The {{jsxref("Proxy.handler", "handler")}} object.</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.html b/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.html
new file mode 100644
index 0000000000..45022b89d1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/reflect/set/index.html
@@ -0,0 +1,146 @@
+---
+title: Reflect.set()
+slug: Web/JavaScript/Reference/Global_Objects/Reflect/set
+translation_of: Web/JavaScript/Reference/Global_Objects/Reflect/set
+---
+<div>{{JSRef}}</div>
+
+<p>O método estático <code><strong>Reflect</strong></code><strong><code>.set()</code></strong> define uma propriedade em um objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">Reflect.set(alvo, propriedade, valor[, receptor])
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>alvo</code></dt>
+ <dd>O objeto alvo onde a propriedade será definida.</dd>
+ <dt><code>propriedade</code></dt>
+ <dd>O nome da propriedade a ser definida.</dd>
+ <dt>valor</dt>
+ <dd>o valor a ser definido para a propriedade.</dd>
+ <dt>receptor</dt>
+ <dd>
+ <p>O valor do <code>this </code>fornecido para a chamada do alvo se um setter é encontrado.</p>
+ </dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Um {{jsxref("Boolean")}} indicando se a definicão da propriedade ocorreu com sucesso ou não.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<p>Um {{jsxref("TypeError")}}, se o <code>alvo</code> não for um {{jsxref("Object")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>Reflect.set</code> permite que você defina uma propriedade em um objeto. Ele define a propriedade e is like the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors">property accessor</a> syntax as a function.</p>
+
+<h2 id="Examplos">Examplos</h2>
+
+<h3 id="Usando_Reflect.set()">Usando <code>Reflect.set()</code></h3>
+
+<pre class="brush: js">// Object
+var obj = {};
+Reflect.set(obj, "prop", "value"); // true
+obj.prop; // "value"
+
+// Array
+var arr = ["duck", "duck", "duck"];
+Reflect.set(arr, 2, "goose"); // true
+arr[2]; // "goose"
+
+// É possível truncar o array
+Reflect.set(arr, "length", 1); // true
+arr; // ["duck"];
+
+// Com apenas um argumento, propertKey e valor são undefined
+var obj = {};
+Reflect.set(obj); // true
+Reflect.getOwnPropertyDescriptor(obj, "undefined");
+// { value: undefined, writable: true, enumerable: true, configurable: true }
+</pre>
+
+<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>{{SpecName('ES6', '#sec-reflect.set', 'Reflect.set')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-reflect.set', 'Reflect.set')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatilibidade_com_navegadores">Compatilibidade com navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>49</td>
+   <td>{{CompatGeckoDesktop(42)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(42)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Reflect")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Property accessors</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.html
new file mode 100644
index 0000000000..de36469d18
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/regexp/compile/index.html
@@ -0,0 +1,84 @@
+---
+title: RegExp.prototype.compile()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/compile
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/compile
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code><strong>compile</strong></code><strong><code>()</code></strong> <span class="tlid-translation translation" lang="pt"><span title=""> está depreciado, é usado para (re-)compilar uma expressão regular durante a execução de um script.</span></span> <span class="tlid-translation translation" lang="pt"><span title="">É basicamente o mesmo que o construtor </span></span> <code>RegExp</code>.</p>
+
+<h2 id="Sintaxe"><span class="tlid-translation translation" lang="pt"><span title="">Sintaxe</span></span></h2>
+
+<pre class="syntaxbox"><code><var>regexObj</var>.compile(<var>pattern, flags</var>)</code></pre>
+
+<h3 id="Parâmetros"><span class="tlid-translation translation" lang="pt"><span title="">Parâmetros</span></span></h3>
+
+<dl>
+ <dt><code>pattern</code></dt>
+ <dd>  <span class="tlid-translation translation" lang="pt"><span title="">É o texto da expressão regular</span></span>.</dd>
+ <dt><code>flags</code></dt>
+ <dd>
+ <p><span class="tlid-translation translation" lang="pt"><span title="">Se especificado, as flags podem ter qualquer combinação dos seguintes valores</span></span>:</p>
+
+ <dl>
+  <dt><code>g</code></dt>
+  <dd>global.</dd>
+  <dt><code>i</code></dt>
+  <dd><span class="tlid-translation translation" lang="pt"><span title="">ignorar caso.</span></span></dd>
+  <dt><code>m</code></dt>
+  <dd><span class="tlid-translation translation" lang="pt"><span title="">multilinha;</span> <span title="">trata os caracteres iniciais e finais como (^ e $), trabalhando sobre várias linhas (isto é, corresponde ao início ou ao final de cada linha (delimitado por \n ou \r), não apenas o começo, ou o final de toda a cadeia de entrada).</span></span></dd>
+  <dt><code>y</code></dt>
+  <dd>sticky; <span class="tlid-translation translation" lang="pt"><span title="">corresponde apenas ao índice indicado pela propriedade</span></span> <code>lastIndex</code> <span class="tlid-translation translation" lang="pt"><span title="">dessa expressão regular na cadeia de destino (e não tenta corresponder a partir de índices posteriores).</span></span></dd>
+ </dl>
+ </dd>
+</dl>
+
+<h2 id="Descrição"><span class="tlid-translation translation" lang="pt"><span title="">Descrição</span></span></h2>
+
+<p> <span class="tlid-translation translation" lang="pt"><span title="">O método de</span></span> <code>compilação</code> <span class="tlid-translation translation" lang="pt"><span title="">é obsoleto.</span> </span> <span class="tlid-translation translation" lang="pt"><span title="">Você pode simplesmente usar o construtor </span></span> <code>RegExp</code> <span class="tlid-translation translation" lang="pt"><span title="">para obter o mesmo efeito.</span></span></p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_compile()"><span class="tlid-translation translation" lang="pt"><span title="">Usando</span></span> <code>compile()</code></h3>
+
+<p><span class="tlid-translation translation" lang="pt"><span title="">O exemplo a seguir mostra como recompilar uma expressão regular com um novo padrão e um nova </span></span>flag.</p>
+
+<pre class="brush: js">var regexObj = new RegExp('foo', 'gi');
+regexObj.compile('new foo', 'g');
+</pre>
+
+<h2 id="Especificações"><span class="tlid-translation translation" lang="pt"><span title="">Especificações</span></span></h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col"><span class="tlid-translation translation" lang="pt"><span title="">Especificação</span></span></th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentario</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition. Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.compile', 'RegExp.prototype.compile')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compativeis">Browser compativeis</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.RegExp.compile")}}</p>
+</div>
+
+<h2 id="Veja_também"><span class="tlid-translation translation" lang="pt"><span title="">Veja também</span></span></h2>
+
+<ul>
+ <li>{{jsxref("RegExp")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.html
new file mode 100644
index 0000000000..b5f722a55d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/regexp/exec/index.html
@@ -0,0 +1,230 @@
+---
+title: RegExp.prototype.exec()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/exec
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/exec
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>exec()</code></strong> executa a busca por um padrão em uma determinada string. Retorna um array, ou {{jsxref("null")}}.</p>
+
+<p>Se você está precisa somente de um retorno verdadeiro/falso, use o método {{jsxref("RegExp.prototype.test()")}} ou {{jsxref("String.prototype.search()")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>regexObj</var>.exec(<var>string</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>string</code></dt>
+ <dd>A string para comparar com a expressão regular</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Se a combinação acontecer, o método <code>exec() </code>o método retorna um array e atualiza as propriedades do objeto da expressão regular. Esse array retornado possui o texto combinado como primeiro item e depois um item para cada captura contendo o respectivo texto.</p>
+
+<p>Se falhar, o retorno do método <code>exec()</code> será {{jsxref("null")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Considere o exemplo abaixo:</p>
+
+<pre class="brush: js">// Encontra combinações "quick brown" seguido de "jumps", ignorando caracteres entre eles
+// Relembra "brown" e "jumps"
+// Ignora caixa (maiúsculo e minúsculo)
+var re = /quick\s(brown).+?(jumps)/ig;
+var result = re.exec('The Quick Brown Fox Jumps Over The Lazy Dog');
+</pre>
+
+<p>A tabela a seguir provê os resultados do script:</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <td class="header">Objeto</td>
+   <td class="header">Propriedade/Índice</td>
+   <td class="header">Descrição</td>
+   <td class="header">Exemplo</td>
+  </tr>
+  <tr>
+   <td rowspan="4"><code>result</code></td>
+   <td><code>[0]</code></td>
+   <td>A string completa dos caracteres encontrados</td>
+   <td><code>Quick Brown Fox Jumps</code></td>
+  </tr>
+  <tr>
+   <td><code>[1], ...[<em>n</em> ]</code></td>
+   <td>As combinações de substrings parametrizadas encontradas, se existir. A quantidade de possíveis substrings parametrizadas é ilimitado.</td>
+   <td><code>[1] = Brown<br>
+    [2] = Jumps</code></td>
+  </tr>
+  <tr>
+   <td><code>index</code></td>
+   <td>
+    <p>O índice base 0 do valor encontrado na string.</p>
+   </td>
+   <td><code>4</code></td>
+  </tr>
+  <tr>
+   <td><code>input</code></td>
+   <td>String original</td>
+   <td><code>The Quick Brown Fox Jumps Over The Lazy Dog</code></td>
+  </tr>
+  <tr>
+   <td rowspan="5"><code>re</code></td>
+   <td><code>lastIndex</code></td>
+   <td>O índice que começa a próxima combinação encontrada. Quando "<code>g</code>" não é definido, este valor será sempre 0.</td>
+   <td><code>25</code></td>
+  </tr>
+  <tr>
+   <td><code>ignoreCase</code></td>
+   <td>Indica se a flag "<code>i</code>" foi usada para ignorar caixa alta/baixa.</td>
+   <td><code>true</code></td>
+  </tr>
+  <tr>
+   <td><code>global</code></td>
+   <td>Indica se a flag "<code>g</code>" foi usada para encontrar combinações de forma global.</td>
+   <td><code>true</code></td>
+  </tr>
+  <tr>
+   <td><code>multiline</code></td>
+   <td>Indica se a flag "<code>m</code>" foi usada para pesquisar em strings de diversas linhas.</td>
+   <td><code>false</code></td>
+  </tr>
+  <tr>
+   <td><code>source</code></td>
+   <td>Texto do padrão.</td>
+   <td><code>quick\s(brown).+?(jumps)</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Procurando_combinações_sucessivas">Procurando combinações sucessivas</h3>
+
+<p>If your regular expression uses the "<code>g</code>" flag, you can use the <code>exec()</code> method multiple times to find successive matches in the same string. When you do so, the search starts at the substring of <code>str</code> specified by the regular expression's {{jsxref("RegExp.lastIndex", "lastIndex")}} property ({{jsxref("RegExp.prototype.test()", "test()")}} will also advance the {{jsxref("RegExp.lastIndex", "lastIndex")}} property). For example, assume you have this script:</p>
+
+<pre class="brush: js">var myRe = /ab*/g;
+var str = 'abbcdefabh';
+var myArray;
+while ((myArray = myRe.exec(str)) !== null) {
+  var msg = 'Found ' + myArray[0] + '. ';
+  msg += 'Next match starts at ' + myRe.lastIndex;
+  console.log(msg);
+}
+</pre>
+
+<p>This script displays the following text:</p>
+
+<pre>Found abb. Next match starts at 3
+Found ab. Next match starts at 9
+</pre>
+
+<p>Note: Do not place the regular expression literal (or {{jsxref("RegExp")}} constructor) within the <code>while</code> condition or it will create an infinite loop if there is a match due to the {{jsxref("RegExp.lastIndex", "lastIndex")}} property being reset upon each iteration. Also be sure that the global flag is set or a loop will occur here also.</p>
+
+<h3 id="Usando_exec()_com_RegExp_literais">Usando <code>exec()</code> com <code>RegExp</code> literais</h3>
+
+<p>You can also use <code>exec()</code> without creating a {{jsxref("RegExp")}} object:</p>
+
+<pre class="brush: js">var matches = /(hello \S+)/.exec('This is a hello world!');
+console.log(matches[1]);
+</pre>
+
+<p>This will log a message containing 'hello world!'.</p>
+
+<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('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.10.6.21', 'RegExp.exec')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-regexp.prototype.exec', 'RegExp.exec')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>O capítulo de <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Expressões Regulares</a> no <a href="/pt-BR/docs/Web/JavaScript/Guide">Guia de Javascript</a>.</li>
+ <li>{{jsxref("RegExp")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.html
new file mode 100644
index 0000000000..e6f55b596f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/regexp/ignorecase/index.html
@@ -0,0 +1,70 @@
+---
+title: RegExp.prototype.ignoreCase
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase
+tags:
+  - JavaScript
+  - Referencia
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/ignoreCase
+---
+<div>{{JSRef}}</div>
+
+<div>O atributo <strong><code>ignoreCase</code></strong> indica se a flag "i" foi ou não utilizada com a expressão regular.</div>
+
+<div><code>ignoreCase</code> é um atributo somente leitura de uma instância individual de expressão</div>
+
+<div>regular. </div>
+
+<div></div>
+
+<p>{{EmbedInteractiveExample("pages/js/regexp-prototype-ignorecase.html")}}</p>
+
+
+
+<div>{{js_property_attributes(0, 0, 1)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O valor de <code>ignoreCase</code> é um {{jsxref("Boolean")}} e<code>true</code> se a flag "<code>i</code>" foi usada; <code>false</code> caso contrário. A flag "i" indica que maiúsculas e minúsculas são equivalentes ao se tentar casar uma string com a expressão regular.</p>
+
+<p>Você não pode alterar essa propriedade diretamente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_ignoreCase">Usando <code>ignoreCase</code></h3>
+
+<pre class="brush: js notranslate">var regex = new RegExp('foo', 'i');
+
+console.log(regex.ignoreCase); // true
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.ignorecase', 'RegExp.prototype.ignoreCase')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.builtins.RegExp.ignoreCase")}}</p>
+</div>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li>{{jsxref("RegExp.lastIndex")}}</li>
+ <li>{{jsxref("RegExp.prototype.global")}}</li>
+ <li>{{jsxref("RegExp.prototype.multiline")}}</li>
+ <li>{{jsxref("RegExp.prototype.source")}}</li>
+ <li>{{jsxref("RegExp.prototype.sticky")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/index.html
new file mode 100644
index 0000000000..99ff4a626d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/regexp/index.html
@@ -0,0 +1,636 @@
+---
+title: RegExp
+slug: Web/JavaScript/Reference/Global_Objects/RegExp
+tags:
+  - Construtor
+  - Expressões Regulares
+  - JavaScript
+  - Referencia
+  - RegExp
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp
+---
+<div>{{JSRef("Global_Objects", "RegExp")}}</div>
+
+<h2 id="Sumário">Sumário</h2>
+
+<p>O construtor <strong><code>RegExp</code></strong> cria um objeto de expressão regular para realizar uma correspondência de texto com um padrão.</p>
+
+<p>Para uma introdução à expressões regulares, leia o <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">capítulo de Expressões Regulares</a> no <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide">Guia de JavaScript</a>.</p>
+
+<h2 id="Syntax" name="Syntax">Construtor</h2>
+
+<p>Notações literais e de construtores são possíveis:</p>
+
+<pre class="syntaxbox"><code><em>/padrão/<var>flags</var></em>
+new RegExp(<em>padrão</em>[, <var>flags</var>])
+RegExp(<em>padrão</em>[, <var>flags</var>])</code>
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>padrão</code></dt>
+ <dd>O texto da expressão regular, ou como em ES5, outro objeto RegExp. Os padrões podem incluir caracteres especiais para correspondencia em um intervalo maior de valores do que uma string literal.</dd>
+ <dt><code>flags</code></dt>
+ <dd>
+ <p>Se especificado, <kbd>flags</kbd>indica os marcadores que podem ser adicionados, ou se um objeto é suficiente para o padrão, os valores de flags serão substituidos por qualquer uma das flags de objetos. O valor de <kbd>flags</kbd>é uma string contendo qualquer combinação dos seguintes valores:</p>
+
+ <dl>
+  <dt><code>g</code></dt>
+  <dd>corresponder globalmente; acha <strong>todas</strong> as correspondências em vez de parar após achar a primeira</dd>
+  <dt><code>i</code></dt>
+  <dd>ignorar maiúsc./minúsc.; Se a <em>flag <kbd>u</kbd></em>  estiver ativa, deve ser utilizado o <em>Unicode case folding</em></dd>
+  <dt><code>m</code></dt>
+  <dd>multilinha; trata caracteres de início e fim (^ e $) ao operar sobre múltiplas linhas (ou seja, corresponder o início ou fim de <em>cada</em> linha (delimitado por \n ou \r), e não apenas o começo ou fim de toda a string de entrada)</dd>
+ </dl>
+
+ <dl>
+  <dt><code>u </code>{{experimental_inline}}</dt>
+  <dd>unicode; trata o padrão como uma sequência de código unicode</dd>
+ </dl>
+
+ <dl>
+  <dt><code>y</code> {{experimental_inline}}</dt>
+  <dd>aderente; corresponde apenas pelo index indicado pela propriedade <code>lastIndex</code> dessa expressão regular na string alvo (e não tenta corresponder de qualquer indexes posteriores).</dd>
+ </dl>
+ </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Há dois modos de criar um objeto <code>RegExp</code>: uma notação literal e um construtor. Para indicar strings, os parâmetros para a notação literal não usam aspas, enquanto os parâmetros para a função do construtor usam. Então, as seguintes expressões criam a mesma expressão regular:</p>
+
+<pre class="brush: js">/ab+c/i;
+new RegExp('ab+c', 'i');
+</pre>
+
+<p>A notação literal compila a expressão regular em tempo de execução. Use a notação literal quando a expressão regular permanecerá constante. Por exemplo, se você usar a notação literal para construir a expressão regular usada em um <em>loop</em>, a expressão regular não será recompilada a cada iteração</p>
+
+<p>O construtor do objeto da expressão regular, por exemplo, <code>new RegExp('ab+c')</code>, fornece uma compilação em tempo de execução da expressão regular. Use a função construtora quando você sabe que o padrão da expressão regular será mudado, ou você não sabe o padrão e o está recebendo de outra fonte, como uma entrada do usuário.</p>
+
+<p>Começando com ECMAScript 6, <code>new RegExp(/ab+c/, 'i')</code>, deixou de lançar um {{jsxref("TypeError")}} ("can't supply flags quando constructing one RegExp from another") quando o primeiro argumento é um <code>RegExp</code> e o segundo argumento <code>flags</code> está presente. Uma nova <code>RegExp</code> dos argumentos é criada ao invés disso.</p>
+
+<p>Quando se usa a função construtora, as regras de escapar em uma string (preceder caracteres especiais com \ quando incluídos na string) são necessárias. Por exemplo, as declarações a seguir são equivalentes:</p>
+
+<pre class="brush: js">var re = /\w+/;
+var re = new RegExp('\\w+');
+</pre>
+
+<h2 id="Special_characters_meaning_in_regular_expressions" name="Special_characters_meaning_in_regular_expressions">Significado dos caracteres especiais nas expressões regulares</h2>
+
+<ul>
+ <li><a href="#character-classes">Classes de Caracteres</a></li>
+ <li><a href="#character-sets">Conjuntos de Caracteres</a></li>
+ <li><a href="#boundaries">Limites</a></li>
+ <li><a href="#grouping-back-references">Agrupamentos e back references</a></li>
+ <li><a href="#quantifiers">Quantificadores</a></li>
+</ul>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr id="character-classes">
+   <th colspan="2">Classes de Caracteres</th>
+  </tr>
+  <tr>
+   <th>Caractere</th>
+   <th>Significado</th>
+  </tr>
+  <tr>
+   <td><code>.</code></td>
+   <td>
+    <p>(O ponto) corresponde um único caracter qualquer <em>exceto</em> os caracteres de nova linha: <code>\n</code>, <code>\r</code>, <code>\u2028</code> ou <code>\u2029</code>.</p>
+
+    <p>Note que a flag multilinha <code>m</code> não muda o comportamento do ponto. Então para corresponder um padrão por múltiplas linhas, o conjunto de caracteres <code>[^]</code> pode ser usado, que corresponderá qualquer caractere, incluindo novas linhas.</p>
+
+    <p>Por exemplo, <code>/.y/</code> corresponde "my" e "ay", mas não "yes", em "yes make my day".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\d</code></td>
+   <td>
+    <p>Corresponde um caractere de dígito no alfabeto basic Latin. Equivalente <code>a [0-9]</code>.</p>
+
+    <p>Por exemplo, <code>/\d/</code> ou <code>/[0-9]/</code> corresponde "2" em "B2 é o número da suíte".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\D</code></td>
+   <td>
+    <p>Corresponde qualquer caractere que não é um dígito no alfabeto basic Latin. Equivalente a <code>[^0-9]</code>.</p>
+
+    <p>Por exemplo, <code>/\D/</code> ou <code>/[^0-9]/</code> corresponde "B" em "B2 é o suite number".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\w</code></td>
+   <td>
+    <p>Corresponde qualquer caractere alfanumérico do alfabeto basic Latin, incluindo o underline. Equivalente a <code>[A-Za-z0-9_]</code>.</p>
+
+    <p>Por exemplo, <code>/\w/</code> corresponde "a" em "apple", "5" em "$5.28", e "3" em "3D".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\W</code></td>
+   <td>
+    <p>Corresponde qualquer caractere que não é um alfanumérico do alfabeto basic Latin. Equivalente a <code>[^A-Za-z0-9_]</code>.</p>
+
+    <p>Por exemplo, <code>/\W/</code> ou <code>/[^A-Za-z0-9_]/</code> corresponde "%" em "50%".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\s</code></td>
+   <td>
+    <p>Corresponde um único caractere de espaço em branco, incluindo espaço, tabulação (tab), quebra de página, nova linha (LF) e outros espaços Unicode. Equivalente a <code>[ \f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u202f\u205f​\u3000]</code>.</p>
+
+    <p>Por exemplo, <code>/\s\w*/</code> corresponde " bar" em "foo bar".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\S</code></td>
+   <td>
+    <p>Corresponde um único caractere que não seja um espaço em branco. Equivalente a <code>[^ \f\n\r\t\v​\u00a0\u1680​\u180e\u2000​\u2001\u2002​\u2003\u2004\u2005\u2006​\u2007\u2008​\u2009\u200a​\u2028\u2029​\u202f\u205f​\u3000]</code>.</p>
+
+    <p>Por exemplo, <code>/\S\w*/</code> corresponde "foo" em "foo bar".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\t</code></td>
+   <td>Corresponde uma tabulação.</td>
+  </tr>
+  <tr>
+   <td><code>\r</code></td>
+   <td>Corresponde uma quebra de linha.</td>
+  </tr>
+  <tr>
+   <td><code>\n</code></td>
+   <td>Corresponde uma nova linha.</td>
+  </tr>
+  <tr>
+   <td><code>\v</code></td>
+   <td>Corresponde uma tabulação vertical.</td>
+  </tr>
+  <tr>
+   <td><code>\f</code></td>
+   <td>Corresponde uma quebra de página.</td>
+  </tr>
+  <tr>
+   <td><code>[\b]</code></td>
+   <td>Corresponde um caracter backspace. (Não confundir com <code>\b</code>)</td>
+  </tr>
+  <tr>
+   <td><code>\0</code></td>
+   <td>Corresponde um caractere NUL. Não coloque outro dígito seguinte a esse.</td>
+  </tr>
+  <tr>
+   <td><code>\c<em>X</em></code></td>
+   <td>
+    <p>Onde <code><em>X</em></code> é uma letra de A - Z. Corresponde um caractere de controle em uma string.</p>
+
+    <p>Por exemplo, <code>/\cM/</code> corresponde control-M em uma string.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\x<em>hh</em></code></td>
+   <td>Corresponde o caractere com o código <code><em>hh</em></code> (dois dígitos hexadecimais).</td>
+  </tr>
+  <tr>
+   <td><code>\u<em>hhhh</em></code></td>
+   <td>Corresponde o caractere com o valor Unicode <code><em>hhhh</em></code> (quatro dígitos hexadecimais).</td>
+  </tr>
+  <tr>
+   <td><code>\</code></td>
+   <td>
+    <p>Para caracteres que são geralmente tratados literalmente, indica que o próximo caractere é especial e não deve ser interpretado literalmente.</p>
+
+    <p>Por exemplo, <code>/b/</code> corresponde o caractere "b". Colocando uma barra invertida antes do "b", ou seja, usando <code>/\b/</code>, o caractere se torna especial, significando corresponder o limite de uma palavra.</p>
+
+    <p><em>ou</em></p>
+
+    <p>Para caracteres que são geralmente tratados especialmente, indica que o próximo caractere não é especial e deve ser interpretado literalmente.</p>
+
+    <p>Por exemplo, "*" é um caractere especial que significa 0 ou mais ocorrências do caractere precedente devem ser correspondidas; por exemplo, <code>/a*/</code> significa corresponder 0 ou mais "a"s. Para corresponder <code>*</code> literalmente, preceda-o com uma barra invertida; por exemplo, <code>/a\*/</code> corresponde "a*".</p>
+   </td>
+  </tr>
+ </tbody>
+ <tbody>
+  <tr id="character-sets">
+   <th colspan="2">Conjuntos de Caracteres</th>
+  </tr>
+  <tr>
+   <th>Caractere</th>
+   <th>Significado</th>
+  </tr>
+  <tr>
+   <td><code>[xyz]</code></td>
+   <td>
+    <p>Um conjunto de caracteres. Corresponde qualquer um dos caracteres cercados. Você pode especificar uma extensão de caracteres usando um hífen.</p>
+
+    <p>Por exemplo, <code>[abcd]</code> é o mesmo que <code>[a-d]</code>. Eles correspondem o "b" em "banco" e o "c" em "cortar".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>[^xyz]</code></td>
+   <td>
+    <p>Um conjunto de caracteres negativo ou complementado. Isto é, corresponde qualquer coisa que não esteja cercada nos colchetes. Você pode especificar uma extensão de caracteres usando um hífen.</p>
+
+    <p>Por exemplo, <code>[^abc]</code> é o mesmo que <code>[^a-c]</code>. Eles inicialmente correspondem "n" em "banco" e "o" em "cortar".</p>
+   </td>
+  </tr>
+ </tbody>
+ <tbody>
+  <tr id="boundaries">
+   <th colspan="2">Limites</th>
+  </tr>
+  <tr>
+   <th>Caractere</th>
+   <th>Significado</th>
+  </tr>
+  <tr>
+   <td><code>^</code></td>
+   <td>
+    <p>Corresponde o início de uma entrada. Se a flag multilinha é utilizada, também corresponde imediatamente após um caractere de quebra de linha.</p>
+
+    <p>Por exemplo, <code>/^A/</code> não corresponde o "A" em "an A", mas corresponde o primeiro "A" em "An A".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>$</code></td>
+   <td>
+    <p>Corresponde o fim de uma entrada. Se a flag multilinha é utilizada, também corresponde imediatamente antes de um caractere de quebra de linha.</p>
+
+    <p>Por exemplo, <code>/o$/</code> não corresponde o "o" em "cantor", mas corresponde em "canto".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\b</code></td>
+   <td>
+    <p>Corresponde um limite de palavra de largura zero, como entre uma letra e um espaço. (Não confundir com <code>[\b]</code>)</p>
+
+    <p>Por exemplo, <code>/\bno/</code> corresponde o "no" em "de noite"; <code>/ly\b/</code> corresponde o "ly" em "possibly yesterday".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\B</code></td>
+   <td>
+    <p>Corresponde um limite de uma não palavra de largura zero, como entre duas letras ou entre dois espaços.</p>
+
+    <p>Por exemplo, <code>/\Bte/</code> corresponde "te" em "de noite", e <code>/on\B/</code> corresponde "on" em "possivelmente ontem".</p>
+   </td>
+  </tr>
+ </tbody>
+ <tbody>
+  <tr id="grouping-back-references">
+   <th colspan="2">Agrupamentos e back references</th>
+  </tr>
+  <tr>
+   <th>Caractere</th>
+   <th>Significado</th>
+  </tr>
+  <tr>
+   <td><code>(<em>x</em>)</code></td>
+   <td>
+    <p>Corresponde <code><em>x</em></code> e memoriza a correspondência. Esses são chamados parênteses de captura.</p>
+
+    <p>Por exemplo, <code>/(foo)/</code> corresponde e memoriza "foo" em "foo bar". A substring correspondida pode ser chamada novamente dos elementos do array resultante <code>[1], ..., [n]</code> ou das propriedades predefinidas do objeto <code>RegExp</code> <code>$1, ..., $9</code>.</p>
+
+    <p>Grupos de captura têm uma falta na performance. Se você não necessita que a substring correspondida seja chamada novamente, prefira parênteses de não-captura (veja mais abaixo).</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>\<em>n</em></code></td>
+   <td>
+    <p>Onde <code><em>n</em></code> é um inteiro positivo. A back reference to o last substring matching o n parenthetical no expressão regular (counting left parentheses).</p>
+
+    <p>Por exemplo, <code>/apple(,)\sorange\1/</code> corresponde "apple, orange," em "apple, orange, cherry, peach". Um exemplo mais completo está a seguir nesta tabela.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code>(?:<em>x</em>)</code></td>
+   <td>Corresponde <code><em>x</em></code> mas não memoriza a correspondência. Esses são chamados parênteses de não-captura. A substring correspondida não pode ser chamada novamente dos elementos do array resultante <code>[1], ..., [n]</code> ou das propriedades predefinidas do objeto <code>RegExp</code> <code>$1, ..., $9</code>.</td>
+  </tr>
+ </tbody>
+ <tbody>
+  <tr id="quantifiers">
+   <th colspan="2">Quantificadores</th>
+  </tr>
+  <tr>
+   <th>Caractere</th>
+   <th>Significado</th>
+  </tr>
+  <tr>
+   <td><code><em>x</em>*</code></td>
+   <td>
+    <p>Corresponde o item precedente <em>x</em> zero ou mais vezes.</p>
+
+    <p>Por exemplo, <code>/assusto*/</code> corresponde "assustoooo" em "Um fantasma assustoooou" e "assust" em "Não me assustei", mas nada em "Um bode grunhiu".</p>
+
+    <p>Note que no caso acima, o único caractere a ser selecionado é "o", pois ele é o caractere imediatamente anterior ao asterisco e não há qualquer operador de agrupamento que indique que mais caracteres deveriam ser submetidos à repetição. Se quiséssemos selecionar a ocorrência sequencial da palavra completa "blah", por exemplo, poderíamos utilizar algum agrupamento como <code>/(blah)*/</code> o que geraria a seleção de "blahblahblah" na frase "blahblahblah ração para gatos" ou de "blah" na frase "algoritmo blahut-arimoto".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code><em>x</em>+</code></td>
+   <td>
+    <p>Corresponde o item precedente <em>x</em> uma ou mais vezes. Equivalente a <code>{1,}</code>.</p>
+
+    <p>Por exemplo, <code>/a+/</code> corresponde o "o" em "doce" e todos os "o"s em "doooooooce".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code><em>x</em>?</code></td>
+   <td>
+    <p>Corresponde o item precedente <em>x</em> nenhuma ou uma vez.</p>
+
+    <p>Por exemplo, <code>/e?le?/</code> corresponde o "el" em "angel" e o "le" em "angle."</p>
+
+    <p>If used imediatamente after qualquer dos quantifiers <code>*</code>, <code>+</code>, <code>?</code>, ou <code>{}</code>, makes o quantifier non-greedy (matching o minimum number of vezes), como opposed to o default, which é greedy (matching o maximum number of vezes).</p>
+
+    <p>Also used em lookahead assertions, described under <code>(?=)</code>, <code>(?!)</code>, e <code>(?:)</code> em this table.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code><em>x</em>(?=<em>y</em>)</code></td>
+   <td>Corresponde <code><em>x</em></code> apenas se <code><em>x</em></code> é seguido por <code><em>y</em></code>. Por exemplo, <code>/Jack(?=Sprat)/</code> corresponde "Jack" apenas se for seguido por "Sprat". <code>/Jack(?=Sprat|Frost)/</code> corresponde "Jack" apenas se for seguido por "Sprat" ou "Frost". Porém, nem "Sprat" nem "Frost" são partes do resultado da correspondência.</td>
+  </tr>
+  <tr>
+   <td><code><em>x</em>(?!<em>y</em>)</code></td>
+   <td>
+    <p>Corresponde <code><em>x</em></code> apenas se <code><em>x</em></code> não é seguido por <code><em>y</em></code>. Por exemplo, <code>/\d+(?!\.)/</code> corresponde um número apenas se não for seguido por um ponto.</p>
+
+    <p><code>/\d+(?!\.)/.exec('3.141')</code> corresponde "141", mas não "3.141".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code><em>x</em>|<em>y</em></code></td>
+   <td>
+    <p>Corresponde <code><em>x</em></code><em> </em>ou <code><em>y</em></code><em>.</em></p>
+
+    <p>Por exemplo, <code>/verde|vermelha/</code> corresponde "verde" em "maçã verde" e "vermelha" em "maçã vermelha".</p>
+
+    <p>Entretanto, a primeira expressão tem preferência. Se uma string fosse corresponder às duas expressões, ela vai corresponder à que aparece do lado esquerdo do operador <code>|</code>. Por exemplo, <code>/maçãs|maçã/</code> corresponde "maçãs" na frase "<u>maçãs</u> vermelhas" e "maçã" na frase "<u>maçã</u> verde".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code><em>x</em>{<em>n</em>}</code></td>
+   <td>
+    <p>Onde <code><em>n</em></code> é um número inteiro positivo. Corresponde exatamente <code><em>n</em></code> ocorrências do item precedente <em>x</em>.</p>
+
+    <p>Por exemplo, <code>/o{2}/</code> não corresponde o "o" em "brigadeiro", mas corresponde todos os dois "o"s em "brigadeir<u>oo</u>", e o dois primeiros "o"s em "brigadeir<u>oo</u>o".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code><em>x</em>{<em>n</em>,}</code></td>
+   <td>
+    <p>Onde <code><em>n</em></code> é um número inteiro positivo. Corresponde <em>pelo menos</em> <code><em>n</em></code> ocorrências do item precedente <em>x </em>(sem que haja um limite superior).</p>
+
+    <p>Por exemplo, <code>/o{2,}/</code> não corresponde o "o" em "brigadeiro", mas corresponde todos os "o"s em "brigadeir<u>oo</u>" e em "brigadeir<u>ooooooooo</u>".</p>
+   </td>
+  </tr>
+  <tr>
+   <td><code><em>x</em>{<em>n</em>,<em>m</em>}</code></td>
+   <td>
+    <p>Onde <code><em>n</em></code> e <code><em>m</em></code> são números inteiros positivos. Corresponde pelo menos <code><em>n</em></code> e no máximo <code><em>m</em></code> ocorrências do item precedente <em>x</em>.</p>
+
+    <p>Por exemplo, <code>/o{2,4}/</code> corresponde nada em "brigadeiro", os dois "o"s em "brigadeir<u>oo</u>", os três "o"s em "brigadeir<u>ooo</u>", e os primeiros quatro "o"s em "brigadeir<u>oooo</u>o".</p>
+
+    <p>É importante perceber que no último caso a correspondência não inclui o último "o" de "brigadeirooooo". Isso se deve ao fato do operador quantificador ter definido o número máximo de ocorrências como 4, ignorando a quinta repetição do caractere.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>
+    <p><code><em>x</em>*?</code><br>
+     <code><em>x</em>+?<br>
+     <em>x??</em><br>
+     <em>x{n,}?</em><br>
+     <em>x{n,m}?</em></code></p>
+   </td>
+   <td>
+    <p><strong>Operadores <em>non-greedy </em>ou<em> lazy</em> (não-gulosos ou preguiçosos)</strong><br>
+     Esses operadores com a <code>?</code> no final, operam de maneira semelhante aos seus análogos sem <code>?</code> mostrados acima, correspondendo múltiplas ocorrências do item precedente <em>x.</em> Entretanto, desta vez a ocorrência selecionada será a mínima possível.</p>
+
+    <p>No exemplo <code>/(blah)*?/</code>, diante da frase "blahblahblah ração para gatos", nada seria selecionado, pois a ocorrência mínima aceita pelo operador <code>*?</code> seria ocorrência de 0 (zero) vezes da <em>string</em> "blah", o que resulta no nada.</p>
+
+    <p>Já a expressão regular <code>/(blah)+?/</code>, diante da mesma frase, corresponderia a "blah", que é a ocorrência mínima aceita pelo operador <code>+?</code><em>, </em>ou seja, 1 (uma) repetição da sequência "blah".</p>
+
+    <p>Em outro exemplo com mais aplicação prática, digamos que se quer corresponder todos os termos que ficam entre aspas em um texto. Se fizéssemos simplesmente a <em>regex</em>  <code>/".*"/</code>, diante de um texto com múltiplas ocorrências de termos entre aspas, como: <em>'Eu "gosto" muito de "estudar" regex'</em>, a nossa expressão regular seria gulosa e selecionaria o maior texto possível que correspondesse à definição, nesse caso, selecionando '<em>"gosto" muito de "estudar"</em>', pois todo esse texto está compreendido entre a primeira aspa (antes de <em>'gosto'</em>) e a última aspa (após <em>'estudar'</em>), o que é um resultado talvez indesejado.<br>
+     Se usarmos a regex <code>/".*?"/</code>, com o operador não-guloso, as correspondências para a mesma frase seriam '<em>"gosto"</em>' e '<em>"estudar"</em>' separadamente, conforme era a intenção inicial.</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("RegExp.prototype")}}</dt>
+ <dd>Permite a adição de propriedades a todos os objetos.</dd>
+ <dt><code>RegExp.length</code></dt>
+ <dd>O valor of <code>RegExp.length</code> é 2.</dd>
+</dl>
+
+<div>{{jsOverrides("Function", "Properties", "prototype")}}</div>
+
+<h2 id="Methods" name="Methods">Métodos</h2>
+
+<p>O objeto global <code>RegExp não possui métodos próprios, no entanto, herda alguns métodos através da cadeia de prototype.</code></p>
+
+<div>{{jsOverrides("Function", "Methods", "prototype")}}</div>
+
+<h2 id="Objetos_e_instancias">Objetos e instancias</h2>
+
+<h3 id="Properties_of_RegExp_instance" name="Properties_of_RegExp_instance">Propriedades</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype', 'Properties')}}</div>
+
+<h3 id="Methods_of_RegExp_instance" name="Methods_of_RegExp_instance">Métodos</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/prototype', 'Methods')}}</div>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Using_a_regular_expression_to_change_data_format" name="Example:_Using_a_regular_expression_to_change_data_format">Exemplo: Usando uma expressão regular para mudar o fomato dos dados</h3>
+
+<p>O seguinte script usa o método {{jsxref("String.prototype.replace()", "replace()")}} da instância de {{jsxref("Global_Objects/String", "String")}} para casar o nome no format <em>nome sobrenome</em> e produzir no formato <em>sobrenome, nome</em>. No texto substituto, o script usa <code>$1</code> e <code>$2</code> para indicar os respectivos parênteses de casamento no padrão da expressão regular.</p>
+
+<pre class="brush: js">var re = /(\w+)\s(\w+)/;
+var str = 'John Smith';
+var newstr = str.replace(re, '$2, $1');
+console.log(newstr);
+</pre>
+
+<p>Isto retornará "Smith, John".</p>
+
+<h3 id="Example_Using_regular_expression_on_multiple_lines" name="Example:_Using_regular_expression_on_multiple_lines">Exemplo: Usando expressões regulares para quebrar linhas com diferentes <strong>fins de linha</strong>/<strong>quebras de linha</strong></h3>
+
+<p>O final de linha padrão depende da plataforma utilizada (Unix, Windows, etc.). A divisão(<em>split</em>) de linha fornecida neste exemplo funciona com todas as plataformas.</p>
+
+<pre class="brush: js">var text = 'Um texto\nE mais um pouco\r\nE ainda mais\rEsse é o fim';
+var lines = text.split(/\r\n|\r|\n/);
+console.log(lines) // prints [ 'Um texto', 'E mais um pouco', 'E ainda mais', 'Esse é o fim' ]</pre>
+
+<p>Note que a ordem dos padrões na expressão regular importa.</p>
+
+<h3 id="Example_Using_regular_expression_on_multiple_lines" name="Example:_Using_regular_expression_on_multiple_lines">Exemplo: Usando expressão regular sobre múltiplas linhas</h3>
+
+<pre class="brush: js">var s = 'Please yes\nmake my day!';
+s.match(/yes.*day/);
+// Retorna null
+s.match(/yes[^]*day/);
+// Retorna'yes\nmake my day'
+</pre>
+
+<h3 id="Example_Using_a_regular_expression_with_the_.22sticky.22_flag" name="Example:_Using_a_regular_expression_with_the_.22sticky.22_flag">Exemplo: Using a expressão regular com o "sticky" flag</h3>
+
+<p>Este exemplo mostra como utilizar a sticky flag em expressões regulares.</p>
+
+<pre class="brush: js">var text = 'First line\nSecond line';
+var regex = /(\S+) line\n?/y;
+
+var match = regex.exec(text);
+console.log(match[1]);        // prints 'First'
+console.log(regex.lastIndex); // prints '11'
+
+var match2 = regex.exec(text);
+console.log(match2[1]);       // prints 'Second'
+console.log(regex.lastIndex); // prints '22'
+
+var match3 = regex.exec(text);
+console.log(match3 === null); // prints 'true'
+</pre>
+
+<p>One can test at run-time whether o sticky flag é supported, using <code>try { … } catch { … }</code>. Para this, either an <code>eval(…)</code> expression ou o <code>RegExp(<var>regex-string</var>, <var>flags-string</var>)</code> syntax must be used (since o <code>/<var>regex</var>/<var>flags</var></code> notation é processed at compile-time, so throws an exception before o <code>catch</code> block é encountered). Por exemplo:</p>
+
+<pre class="brush: js">var supports_sticky;
+try { RegExp('', 'y'); supports_sticky = true; }
+catch(e) { supports_sticky = false; }
+console.log(supports_sticky); // prints 'true'
+</pre>
+
+<h3 id="Example_Regular_expression_and_Unicode_characters" name="Example:_Regular_expression_and_Unicode_characters">Exemplo: Expressão regular e Unicode caracteres</h3>
+
+<p>As mentioned above, <code>\w</code> ou <code>\W</code> only corresponde ASCII based caracteres; por exemplo, "a" to "z", "A" to "Z", "0" to "9" e "_". To match caracteres from other languages such como Cyrillic ou Hebrew, use <code>\uhhhh</code>, onde "hhhh" é o caractere's Unicode valor em hexadecimal. This exemplo demonstrates how one can separate out Unicode caracteres from uma palavra.</p>
+
+<pre class="brush: js">var text = 'Образец text на русском языке';
+var regex = /[\u0400-\u04FF]+/g;
+
+var match = regex.exec(text);
+console.log(match[0]);        // prints 'Образец'
+console.log(regex.lastIndex); // prints '7'
+
+var match2 = regex.exec(text);
+console.log(match2[0]);       // prints 'на' [não print 'text']
+console.log(regex.lastIndex); // prints '15'
+
+// e assim vai
+</pre>
+
+<p>Here's an external resource para getting o complete Unicode block range para different scripts: <a href="http://kourge.net/projects/regexp-unicode-block">Regexp-unicode-block</a>.</p>
+
+<h3 id="Example_Extracting_subdomain_name_from_URL" name="Example:_Extracting_subdomain_name_from_URL">Exemplo: Extracting subdomain name from URL</h3>
+
+<pre class="brush: js">var url = 'http://xxx.domain.com';
+console.log(/[^.]+/.exec(url)[0].substr(7)); // prints 'xxx'
+</pre>
+
+<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. Implemented em JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.10', 'RegExp')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-regexp-regular-expression-objects', 'RegExp')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Sticky flag ("y")</td>
+   <td>{{CompatChrome("39")}} (behind flag)</td>
+   <td>{{CompatGeckoDesktop("1.9")}} ES4-Style {{bug(773687)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Sticky flag ("y")</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("1.9")}} ES4-Style {{bug(773687)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter no <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li>
+ <li>{{jsxref("String.prototype.match()")}}</li>
+ <li>{{jsxref("String.prototype.replace()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.html
new file mode 100644
index 0000000000..2030fc7bf1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/regexp/sticky/index.html
@@ -0,0 +1,95 @@
+---
+title: RegExp.prototype.sticky
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/sticky
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/sticky
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <strong><code>sticky</code></strong> indica se a busca é "pegajosa" (percorre a string somente a partir do índice indicado pela propriedade {{jsxref("RegExp.lastIndex", "lastIndex")}} desta expressão regular). A propriedade <code>sticky</code> em um objeto de expressão regular é somente para leitura.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/regexp-prototype-sticky.html")}}</div>
+
+<p class="hidden">O código fonte para este exemplo interativo está armazenado em um repositório GitHub. Caso deseje contribuir com o projeto de exemplos interativos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um <em>pull request</em>.</p>
+
+<div>{{js_property_attributes(0, 0, 1)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O valor de <code>sticky</code> é do tipo {{jsxref("Boolean")}} e será  <em>true </em>quando a flag "<code>y</code>" for utilizada; senão, será <em>false</em>. A flag "<code>y</code>" indica que as correspondências ocorrerão apenas a partir do indice indicado pela propriedade {{jsxref("RegExp.lastIndex", "lastIndex")}} desta expressão regular na string alvo (e não buscará correspondência em nenhum índice anterior). Uma expressão regular definida como <code>sticky</code> e <code>global</code> ignora a flag <code>global</code>.</p>
+
+<p>Você não pode alterar essa propriedade diretamente. Ela é somente para leitura.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Uilizando_uma_expressão_regular_com_a_flag_sticky">Uilizando uma expressão regular com a flag <em>sticky</em></h3>
+
+<pre class="brush: js">var str = '#foo#';
+var regex = /foo/y;
+
+regex.lastIndex = 1;
+regex.test(str); // true
+regex.lastIndex = 5;
+regex.test(str); // false (lastIndex é levado em conta com a flag sticky)
+regex.lastIndex; // 0 (reinicia quando não ocorre correspondência)
+</pre>
+
+<h3 id="Flag_sticky_ancorada">Flag sticky ancorada</h3>
+
+<p>Por diversas versões, a engine SpiderMonkey do Firefox apresentou um<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=773687"> bug</a> na asserção de <code>^</code> com a flag <em>sticky </em>que fazia expressões iniciando com <code>^</code> e usando a flag <em>sticky </em>encontrarem correspondências onde não deveriam. O bug foi introduzido algum tempo após o Firefox 3.6 (que possuía a flag sticky mas não apresentava o bug) e corrigido em 2015. Talvez por este motivo, a especificação ES2015 <a href="http://www.ecma-international.org/ecma-262/7.0/index.html#sec-assertion">destaca especificamente</a> que:</p>
+
+<blockquote>
+<p>Quando a flag <code>y</code> for usada em um padrão, ^ indica que a correspondência ocorrerá apenas no início da entrada, ou (se <code>multiline</code> for <code>true</code>) no início de uma linha.</p>
+</blockquote>
+
+<p>Exemplos de comportamento esperado:</p>
+
+<pre class="brush: js">var regex = /^foo/y;
+regex.lastIndex = 2;
+regex.test('..foo');   // false - índice 2 não é o início da string
+
+var regex2 = /^foo/my;
+regex2.lastIndex = 2;
+regex2.test('..foo');  // false - índice 2 não é o início da string nem da linha
+regex2.lastIndex = 2;
+regex2.test('.\nfoo'); // true - índice 2 é o início da linha
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-get-regexp.prototype.sticky', 'RegExp.prototype.sticky')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Caso deseje contribuir, consulte <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.builtins.RegExp.sticky")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("RegExp.lastIndex")}}</li>
+ <li>{{jsxref("RegExp.prototype.global")}}</li>
+ <li>{{jsxref("RegExp.prototype.ignoreCase")}}</li>
+ <li>{{jsxref("RegExp.prototype.multiline")}}</li>
+ <li>{{jsxref("RegExp.prototype.source")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.html b/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.html
new file mode 100644
index 0000000000..c3470dc4fe
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/regexp/test/index.html
@@ -0,0 +1,152 @@
+---
+title: RegExp.prototype.test()
+slug: Web/JavaScript/Reference/Global_Objects/RegExp/test
+tags:
+  - Expressão Regular
+  - JavaScript
+  - Prototype
+  - Referencia
+  - RegExp
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/RegExp/test
+---
+<div>{{JSRef}}</div>
+
+<div>O método <strong>test() </strong>executa uma busca por uma correspondência entre  uma expressão regular e uma string. Retorna <code>true</code> ou <code>false</code>.</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>regexObj</var>.test(<var>str</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>str</code></dt>
+ <dd>A string que confrontará a expressão regular.</dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Boolean.</p>
+
+<p><code>true</code> se a string <code>str</code> corresponde com o que está descrito na expressão regular.</p>
+
+<p>Caso contrário, retorna <code>false</code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Use test() sempre que você quiser saber se um padrão está dentro de uma string( similar ao método {{jsxref("String.prototype.search()")}}); Para mais informações (porém com execução mais lenta) use o método {{jsxref("RegExp.prototype.exec()", "exec()")}} (similar ao método {{jsxref("String.prototype.match()")}}). Assim como {{jsxref("RegExp.prototype.exec()", "exec()")}} (ou em combinação com ele), test() quando chamado várias vezes dentro da mesma instância de expressão regular irá avançar seu ponteiro para a correspondência anterior.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_test">Usando <code>test()</code></h3>
+
+<p>Exemplo simples que verifica se <code>"hello"</code> está presente no início de uma string, retornando um booleano como resultado.</p>
+
+<pre class="notranslate">const str = 'hello world!';
+const result = /^hello/.test(str);
+
+console.log(result); // true</pre>
+
+<p>O exemplo a seguir mostra uma mensagem dependendo do sucesso do teste.</p>
+
+<pre class="brush: js notranslate">function testinput(re, str){
+  var midstring;
+  if (re.test(str)) {
+    midstring = ' Contém ';
+  } else {
+    midstring = ' não contém ';
+  }
+  console.log(str + midstring + re.source);
+}
+</pre>
+
+<h2 id="Specificações">Specificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.10.6.3', 'RegExp.test')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-regexp.prototype.test', 'RegExp.test')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Browser">Compatibilidade com Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Gecko-specific_notes">Gecko-specific notes</h2>
+
+<p>A priori no Grecko 8.0 {{geckoRelease("8.0")}}, <code>test()</code> foi implementado incorretamente; quando chamado sem parâmetros, ele encontrária uma correspondência com o valor de entrada anterior (<code>RegExp.input</code> property) no lugar de uma correspondência com <code>"undefined"</code>. Isso está conrrigido; agora <code>/undefined/.test()</code> resultará em <code>true</code>, no lugar de um erro.</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Regular Expressions</a> chapter in the <a href="/en-US/docs/Web/JavaScript/Guide">JavaScript Guide</a></li>
+ <li>{{jsxref("RegExp")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/set/add/index.html b/files/pt-br/web/javascript/reference/global_objects/set/add/index.html
new file mode 100644
index 0000000000..c3787149df
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/set/add/index.html
@@ -0,0 +1,131 @@
+---
+title: Set.prototype.add()
+slug: Web/JavaScript/Reference/Global_Objects/Set/add
+tags:
+  - ECMAScript6
+  - JavaScript
+  - Prototype
+  - metodo
+  - set
+  - set.add
+translation_of: Web/JavaScript/Reference/Global_Objects/Set/add
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>add()</strong></code> acrescenta um novo elemento com o valor especificado no final de um objeto <code>Set</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>mySet</em>.add(value);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>value</dt>
+ <dd>Requerido. O valor de um elemento a ser adicionado ao objeto Set.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p><font face="Open Sans, Arial, sans-serif">O objeto </font><code>Set</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_add">Usando o método <code>add</code></h3>
+
+<pre class="brush: js">var mySet = new Set();
+
+mySet.add(1);
+mySet.add(5).add("some text"); // pode ser encadeado
+
+console.log(mySet);
+// Set [1, 5, "some text"]
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-set.prototype.add', 'Set.prototype.add')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype.add', 'Set.prototype.add')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatilidade_de_Navegadores_(Browser)">Compatilidade de Navegadores (Browser)</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>38</td>
+   <td>{{CompatGeckoDesktop("13.0")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatGeckoMobile("13.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_específicas_para_Firefox">Notas específicas para Firefox</h2>
+
+<ul>
+ <li>Antes do Firefox 33 {{geckoRelease("33")}}, <code>Set.prototype.add retornava</code> <code>undefined</code> e não era possível encadear chamadas. Isto foi resolvido ({{bug(1031632)}}). O comportamento pode ser encontrado no Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">issue</a>).</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("Set.prototype.delete()")}}</li>
+ <li>{{jsxref("Set.prototype.has()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/set/clear/index.html b/files/pt-br/web/javascript/reference/global_objects/set/clear/index.html
new file mode 100644
index 0000000000..1026fe61f1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/set/clear/index.html
@@ -0,0 +1,110 @@
+---
+title: Set.prototype.clear()
+slug: Web/JavaScript/Reference/Global_Objects/Set/clear
+translation_of: Web/JavaScript/Reference/Global_Objects/Set/clear
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>clear()</strong></code> remove todos os elementos de um objeto <code>Set</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>mySet</em>.clear();</code></pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_clear">Usando o método <code>clear</code></h3>
+
+<pre class="brush: js">var mySet = new Set();
+mySet.add(1);
+mySet.add("foo");
+
+mySet.size;       // 2
+mySet.has("foo"); // true
+
+mySet.clear();
+
+mySet.size;       // 0
+mySet.has("bar")  // false
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definições iniciais</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype.clear', 'Set.prototype.clear')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores_(Browser)">Compatibilidade de navegadores (Browser)</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{CompatGeckoDesktop("19.0")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>{{CompatGeckoMobile("19.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("Set.prototype.delete()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/set/delete/index.html b/files/pt-br/web/javascript/reference/global_objects/set/delete/index.html
new file mode 100644
index 0000000000..0683060777
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/set/delete/index.html
@@ -0,0 +1,123 @@
+---
+title: Set.prototype.delete()
+slug: Web/JavaScript/Reference/Global_Objects/Set/delete
+tags:
+  - ECMAScript6
+  - ES6
+  - Prototype
+  - metodo
+  - set
+translation_of: Web/JavaScript/Reference/Global_Objects/Set/delete
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>delete()</strong></code> remove o elemento especificado de um objeto <code>Set</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>mySet</em>.delete(value);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>value</dt>
+ <dd>Requerido. O valor do elemento a ser removido do objeto Set.</dd>
+</dl>
+
+<h3 id="Return_value">Return value</h3>
+
+<p>Retorna <code>true</code> se um elemento contido no objeto Set foi removido com sucesso; caso contrário <code>false</code>.</p>
+
+<h2 id="Exemples">Exemples</h2>
+
+<h3 id="Uso_do_método_delete">Uso do método <code>delete</code></h3>
+
+<pre class="brush: js">var mySet = new Set();
+mySet.add("foo");
+
+mySet.delete("bar"); // Retorna false. Nenhum elemento "bar" foi encontrado para deletar.
+mySet.delete("foo"); // Retorna true. remoção bem sucedida.
+
+mySet.has("foo");    // Retorna false. O elemento "foo" não está mais presente.
+</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-set.prototype.delete', 'Set.prototype.delete')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype.delete', 'Set.prototype.delete')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores_(Browser)">Compatibilidade de Navegadores (Browser)</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>38</td>
+   <td>{{CompatGeckoDesktop("13.0")}}</td>
+   <td>11</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{CompatGeckoMobile("13.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("Set.prototype.clear()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/set/entries/index.html b/files/pt-br/web/javascript/reference/global_objects/set/entries/index.html
new file mode 100644
index 0000000000..67bc464a4e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/set/entries/index.html
@@ -0,0 +1,109 @@
+---
+title: Set.prototype.entries()
+slug: Web/JavaScript/Reference/Global_Objects/Set/entries
+translation_of: Web/JavaScript/Reference/Global_Objects/Set/entries
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>entries()</strong></code> retorna um novo objeto Iterador (<code>Iterator</code>) que contém <strong>um array de [valor, valor]</strong> para cada elemento de um objeto <code>Set </code>em ordem de inserção. Os objetos <code>Set </code>não possuem <code>chaves (key) </code>como objetos do tipo <code>Map</code>. Entretanto, para manter a API similar a objetos <code>Map</code>, cada entrada (<em>entry</em>) tem o mesmo valor para sua chave (<code>key</code>) e valor (<code>value</code>), então uma matriz <code>array [valor, valor]</code> é retornado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>mySet</em>.entries()</code></pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_entries()">Usando <code>entries()</code></h3>
+
+<pre class="brush:js">var mySet = new Set();
+mySet.add("foobar");
+mySet.add(1);
+mySet.add("baz");
+
+var setIter = mySet.entries();
+
+console.log(setIter.next().value); // ["foobar", "foobar"]
+console.log(setIter.next().value); // [1, 1]
+console.log(setIter.next().value); // ["baz", "baz"]
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-set.prototype.entries', 'Set.prototype.entries')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype.entries', 'Set.prototype.entries')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores_(Browser)">Compatibilidade de navegadores (Browser)</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>38</td>
+   <td>{{ CompatGeckoDesktop("24") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>38</td>
+   <td>{{ CompatGeckoMobile("24") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Set.prototype.keys()")}}</li>
+ <li>{{jsxref("Set.prototype.values()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/set/has/index.html b/files/pt-br/web/javascript/reference/global_objects/set/has/index.html
new file mode 100644
index 0000000000..1a3f5d68c8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/set/has/index.html
@@ -0,0 +1,86 @@
+---
+title: Set.prototype.has()
+slug: Web/JavaScript/Reference/Global_Objects/Set/has
+translation_of: Web/JavaScript/Reference/Global_Objects/Set/has
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>has()</strong></code><strong> </strong>retorna um valor booleano indicando se um elemento com o valor especificado existe em um objecto <code>Set</code> ou não.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/set-prototype-has.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><em>mySet</em>.has(<em>valor</em>);</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>valor</code></dt>
+ <dd>O valor para testar a existência no objeto <code>Set</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Retorna <code>true</code> se um elemento com o valor especificado existe no objeto <code>Set</code>; <code>false</code> caso contrário.</p>
+
+<div class="blockIndicator note">
+<p><strong>Nota: </strong>Tecnicamente falando, <code>has()</code> usa o algorítimo <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness#Same-value-zero_equality">sameValueZero</a></code> para determinar quando o elemento dado é encontrado.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_método_has">Usando o método <code>has</code></h3>
+
+<pre class="brush: js">var mySet = new Set();
+mySet.add('foo');
+
+mySet.has('foo');  // retorna true
+mySet.has('bar');  // retorna false
+
+var set1 = new Set();
+var obj1 = {'key1': 1};
+set1.add(obj1);
+
+set1.has(obj1);        // retorna true
+set1.has({'key1': 1}); // retorna false porque obj1 e {'key': 1} fazem referência a objetos diferentes.
+set1.add({'key1': 1}); // agora set1 contém 2 registros
+</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('ES2015', '#sec-set.prototype.has', 'Set.prototype.has')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype.has', 'Set.prototype.has')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Set.has")}}</p>
+
+<h2 id="Veja_também">Veja também:</h2>
+
+<ul>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("Set.prototype.add()")}}</li>
+ <li>{{jsxref("Set.prototype.delete()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/set/index.html b/files/pt-br/web/javascript/reference/global_objects/set/index.html
new file mode 100644
index 0000000000..261359a0b0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/set/index.html
@@ -0,0 +1,259 @@
+---
+title: Set
+slug: Web/JavaScript/Reference/Global_Objects/Set
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Objetos
+  - Objetos Globais
+  - conjuntos
+translation_of: Web/JavaScript/Reference/Global_Objects/Set
+---
+<div>{{JSRef("Global_Objects", "Set")}}</div>
+
+<h2 id="Sumário">Sumário</h2>
+
+<p>O objeto <strong><code>Set</code></strong> permite que você armazene valores <em>únicos</em> de qualquer tipo, desde {{Glossary("Primitive", "valores primitivos")}} a referências a objetos.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"> new Set([iterable]);</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>iterable</dt>
+ <dd>Se um <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">objeto iterável </a>é passado, todos os seus elementos serão adicionados ao novo Set. Se tal parâmetro não for específicado, ou se seu valor for <code>null</code>, o novo <code>Set</code> estará vazio.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Objetos <code style="font-style: normal; line-height: 1.5;">Set</code><span style="line-height: 1.5;"> são coleções de valores nas quais é possível iterar os elementos em ordem de inserção. Um valor no </span><code style="font-style: normal; line-height: 1.5;">Set</code><span style="line-height: 1.5;"> <strong>pode ocorrer apenas uma vez</strong>; ele é único na coleção do </span><code style="font-style: normal; line-height: 1.5;">Set</code><span style="line-height: 1.5;">.</span></p>
+
+<h3 id="Igualdade_de_valores">Igualdade de valores</h3>
+
+<p>Como cada valor no Set deve ser único, a igualdade será checada e não é baseada no mesmo algoritmo que aquele usado no operador ===. Especificamente, para <code>Set</code>s, <code>+0</code> (que é exatamente igual a - 0) e <code>- 0</code> são valores diferentes. No entanto, isto foi modificado na última especificação ECMAScript 2015. Iniciado com o Gecko 29.0 {{geckoRelease("29")}} ({{bug("952870")}}) e pelo  <a href="https://code.google.com/p/v8/issues/detail?id=3069">recent nightly Chrome</a>, +0 e -0 são tratados com sendo o mesmo valor em objetos conjunto (Set). Também, <code>NaN</code> e <code>undefined </code>podem ser armazenados em um conjunto Set.</p>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt><code>Set.length</code></dt>
+ <dd>O valor da propriedade comprimento é 0.</dd>
+ <dd>Para contar o número de elementos de um <code>Set</code>, use {{jsxref("Set.prototype.size")}}.</dd>
+ <dt>{{jsxref("Set.@@species", "get Set[@@species]")}}</dt>
+ <dd>A função construtora usada para criar objetos derivados.</dd>
+ <dt>{{jsxref("Set.prototype")}}</dt>
+ <dd>Representa o prototype do constructor do <code>Set</code>. Permite a adição de propriedades para todos os objetos do tipo <code>Set</code>.</dd>
+</dl>
+
+<h2 id="Boolean_instances" name="Boolean_instances">Instâncias <code>Set</code> </h2>
+
+<p>Todas as instâncias de <code>Set</code> herdam de {{jsxref("Set.prototype")}}.</p>
+
+<h3 id="Propriedades">Propriedades</h3>
+
+<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Set/prototype','Properties')}}</p>
+
+<h3 id="Métodos">Métodos</h3>
+
+<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/Set/prototype','Methods')}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_o_objeto_Set">Utilizando o objeto <code>Set</code></h3>
+
+<pre class="brush: js">var meuSet = new Set();
+
+meuSet.add(1); // meuSet [1]
+meuSet.add(5); // meuSet [1, 5]
+meuSet.add(5); // 5 já foi adicionando, portanto, meuSet [1, 5]
+meuSet.add("texto");
+var o = {a: 1, b: 2};
+meuSet.add(o);
+
+meuSet.add({a: 1, b: 2}); //  o está referenciando outro objeto
+
+meuSet.has(1); // true
+meuSet.has(3); // false, 3 não foi adicionado ao set (Conjunto)
+meuSet.has(5);              // true
+meuSet.has(Math.sqrt(25));  // true
+meuSet.has("Texto".toLowerCase()); // true
+meuSet.has(o); // true
+
+meuSet.size; // 5
+
+meuSet.delete(5); // remove 5 do set
+meuSet.has(5);    // false, 5 já foi removido
+
+meuSet.size; // 4, nós simplesmente removemos um valor
+
+console.log(meuSet) // Set { 1, 'texto', { a: 1, b: 2 }, { a: 1, b: 2 } }
+</pre>
+
+
+
+<h3 id="Iterando_objetos_Set">Iterando objetos <code>Set</code></h3>
+
+<pre class="brush: js">// iterar sobre os itens em set
+// loga os itens na ordem: 1, "texto"
+for (let item of meuSet) console.log(item);
+
+// loga os itens na ordem: 1, "texto"
+for (let item of meuSet.keys()) console.log(item);
+
+// loga os itens na ordem: 1, "texto"
+for (let item of meuSet.values()) console.log(item);
+
+// loga os itens na ordem: 1, "texto"
+//(key e value são os mesmos aqui)
+for (let [key, value] of meuSet.entries()) console.log(key);
+
+// converte Set para um Array
+var meuArr = [v for (v of mySet)]; // [1, "some text"]
+
+// o seguinte também funcionará se for executado em um documento HTML
+mySet.add(document.body);
+mySet.has(document.querySelector("body")); // true
+
+// a conversão entre Set e Array
+mySet2 = Set([1,2,3,4]);
+mySet2.size; // 4
+[...mySet2]; // [1,2,3,4]
+
+// intersecção pode ser simulado via
+var intersection = new Set([...set1].filter(x =&gt; set2.has(x)));
+
+// Iterar entradas set com forEach
+meuSet.forEach(function(value) {
+  console.log(value);
+});
+
+// 1
+// 2
+// 3
+// 4</pre>
+
+<h3 id="Implementando_operações_básicas_entre_conjuntos">Implementando operações básicas entre conjuntos</h3>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">function</span> is<span class="function token">Superset</span><span class="punctuation token">(</span><span class="keyword token">set</span><span class="punctuation token">,</span> subset<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> subset<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+        <span class="keyword token">if</span> <span class="punctuation token">(</span><span class="operator token">!</span><span class="keyword token">set</span><span class="punctuation token">.</span><span class="function token">has</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+            <span class="keyword token">return</span> <span class="keyword token">false</span><span class="punctuation token">;</span>
+        <span class="punctuation token">}</span>
+    <span class="punctuation token">}</span>
+    <span class="keyword token">return</span> <span class="keyword token">true</span><span class="punctuation token">;</span>
+<span class="punctuation token">}</span>
+
+<span class="keyword token">function</span> <span class="function token">uniao</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">var</span> _uniao <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>setA<span class="punctuation token">)</span><span class="punctuation token">;</span>
+    <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+        _uniao<span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span>
+    <span class="punctuation token">}</span>
+    <span class="keyword token">return</span> _uniao<span class="punctuation token">;</span>
+<span class="punctuation token">}</span>
+
+<span class="keyword token">function</span> <span class="function token">interseccao</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">var</span> _<span class="function token">interseccao</span> <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+    <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+        <span class="keyword token">if</span> <span class="punctuation token">(</span>setA<span class="punctuation token">.</span><span class="function token">has</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+            _<span class="function token">interseccao</span><span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span>
+        <span class="punctuation token">}</span>
+    <span class="punctuation token">}</span>
+    <span class="keyword token">return</span> _<span class="function token">interseccao</span><span class="punctuation token">;</span>
+<span class="punctuation token">}</span>
+
+<span class="keyword token">function</span> <span class="function token">diferencaSimetrica</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">var</span> _diferenca <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>setA<span class="punctuation token">)</span><span class="punctuation token">;</span>
+    <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+        <span class="keyword token">if</span> <span class="punctuation token">(</span>_diferenca<span class="punctuation token">.</span><span class="function token">has</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+            _diferenca<span class="punctuation token">.</span><span class="keyword token">delete</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span>
+        <span class="punctuation token">}</span> <span class="keyword token">else</span> <span class="punctuation token">{</span>
+            _diferenca<span class="punctuation token">.</span><span class="function token">add</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span>
+        <span class="punctuation token">}</span>
+    <span class="punctuation token">}</span>
+    <span class="keyword token">return</span> _diferenca<span class="punctuation token">;</span>
+<span class="punctuation token">}</span>
+
+<span class="keyword token">function</span> <span class="function token">diferenca</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="keyword token">var</span> _diferenca <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>setA<span class="punctuation token">)</span><span class="punctuation token">;</span>
+    <span class="keyword token">for</span> <span class="punctuation token">(</span><span class="keyword token">var</span> elem <span class="keyword token">of</span> setB<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+        _diferenca<span class="punctuation token">.</span><span class="keyword token">delete</span><span class="punctuation token">(</span>elem<span class="punctuation token">)</span><span class="punctuation token">;</span>
+    <span class="punctuation token">}</span>
+    <span class="keyword token">return</span> _diferenca<span class="punctuation token">;</span>
+<span class="punctuation token">}</span>
+
+<span class="comment token">//Exemplos</span>
+<span class="keyword token">var</span> setA <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">1</span><span class="punctuation token">,</span> <span class="number token">2</span><span class="punctuation token">,</span> <span class="number token">3</span><span class="punctuation token">,</span> <span class="number token">4</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">,</span>
+    setB <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">2</span><span class="punctuation token">,</span> <span class="number token">3</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">,</span>
+    setC <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span><span class="punctuation token">[</span><span class="number token">3</span><span class="punctuation token">,</span> <span class="number token">4</span><span class="punctuation token">,</span> <span class="number token">5</span><span class="punctuation token">,</span> <span class="number token">6</span><span class="punctuation token">]</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+
+<span class="function token">isSuperset</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setB<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// =&gt; true</span>
+<span class="function token">uniao</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// =&gt; Set [1, 2, 3, 4, 5, 6]</span>
+<span class="function token">interseccao</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// =&gt; Set [3, 4]</span>
+<span class="function token">diferencaSimetrica</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// =&gt; Set [1, 2, 5, 6]</span>
+<span class="function token">diferenca</span><span class="punctuation token">(</span>setA<span class="punctuation token">,</span> setC<span class="punctuation token">)</span><span class="punctuation token">;</span> <span class="comment token">// =&gt; Set [1, 2]</span></code></pre>
+
+<h3 id="Relação_com_objetos_Array">Relação com objetos <code>Array</code> </h3>
+
+<pre class="brush: js">var myArray = ["value1", "value2", "value3"];
+
+// Use o construtor regular de Set para transformar um array dentro de um Set
+var mySet = new Set(myArray);
+
+mySet.has("value1"); // retorna true
+
+// Use o operador de propagação para transformar um Set em um Array.
+alert(uneval([...mySet])); // Irá mostrar-lhe exatamente o mesmo Array como myArray</pre>
+
+<h3 id="Removendo_elementos_duplicados_de_um_Array">Removendo elementos duplicados de um <code>Array</code></h3>
+
+<pre class="line-numbers  language-html"><code class="language-html">// Use para remover elementos duplicados de um Array
+
+const numeros = [2,3,4,4,2,3,3,4,4,5,5,6,6,7,5,32,3,4,5]
+
+console.log([...new Set(numeros)])
+
+// [2, 3, 4, 5, 6, 7, 32]</code></pre>
+
+<h3 id="Relação_com_objetos_String">Relação com objetos <code>String</code></h3>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">var</span> texto <span class="operator token">=</span> <span class="string token">'India'</span><span class="punctuation token">;</span>
+
+<span class="keyword token">var</span> meuSet <span class="operator token">=</span> <span class="keyword token">new</span> <span class="class-name token">Set</span><span class="punctuation token">(</span>texto<span class="punctuation token">)</span><span class="punctuation token">;</span>  <span class="comment token">// Set ['I', 'n', 'd', 'i', 'a']</span>
+meuSet<span class="punctuation token">.</span>size<span class="punctuation token">;</span>  <span class="comment token">// 5</span></code></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('ES2015', '#sec-set-objects', 'Set')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set-objects', 'Set')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador_Browser">Compatibilidade de navegador (Browser)</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Set")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("WeakMap")}}</li>
+ <li>{{jsxref("WeakSet")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/set/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/set/prototype/index.html
new file mode 100644
index 0000000000..2438fccc1c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/set/prototype/index.html
@@ -0,0 +1,84 @@
+---
+title: Set.prototype
+slug: Web/JavaScript/Reference/Global_Objects/Set/prototype
+tags:
+  - Propriedade
+  - Prototipo
+  - set
+translation_of: Web/JavaScript/Reference/Global_Objects/Set
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code><strong>Set</strong></code><strong><code>.prototype</code></strong> representa o protótipo do construtor do objeto {{jsxref("Set")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Instâncias de {{jsxref("Set")}} herdam de {{jsxref("Set.prototype")}}. Você pode usar o construtor do objeto protótipo para adicionar propriedades ou métodos para todas as instâncias de <code>Set</code> .</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>Set.prototype.constructor</code></dt>
+ <dd>Retorna a função que criou o protótipo de uma instância. Esta é a função {{jsxref("Set")}} por padrão.</dd>
+ <dt>{{jsxref("Set.prototype.size")}}</dt>
+ <dd>Retorna o número de valores no objeto <code>Set</code>.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Set.add", "Set.prototype.add(value)")}}</dt>
+ <dd>Anexa um novo elemento com o valor passado ao objeto <code>Set</code> . Retorna o objeto <code>Set</code>.</dd>
+ <dt>{{jsxref("Set.prototype.clear()")}}</dt>
+ <dd>Remove todos os elementos do objeto <code>Set</code>.</dd>
+ <dt>{{jsxref("Set.delete", "Set.prototype.delete(value)")}}</dt>
+ <dd>Remove o elemento associado ao <code>value</code> e retorna o valor que <code>Set.prototype.has(value)</code> teria retornado anteriormente. <code>Set.prototype.has(value)</code> irá retornar <code>false</code> depois disso.</dd>
+ <dt>{{jsxref("Set.prototype.entries()")}}</dt>
+ <dd>Retorna um novo objeto <code>Iterator</code> que contém<strong> um array de <code>[value, value]</code></strong> para cada elemento no objeto <code>Set</code> , em ordem de inserção. Isso é similar ao objeto <code>Map</code>, para que cada entrada tenha o mesmo valor para sua <em>chave</em> e<em>valor </em>aqui.</dd>
+ <dt>{{jsxref("Set.forEach", "Set.prototype.forEach(callbackFn[, thisArg])")}}</dt>
+ <dd>Chama <code>callbackFn</code> uma vez para cada valor presente no objeto <code>Set</code>, em ordem de inserção. Se um parâmetro <code>thisArg</code> for passado para o <code>forEach</code>, ele será usado como valor de <code>this</code> para cada callback.</dd>
+ <dt>{{jsxref("Set.has", "Set.prototype.has(value)")}}</dt>
+ <dd>Retorna um booleano afirmando se um elemento está presente com o dado valor no objeto <code>Set</code> ou não.</dd>
+ <dt>{{jsxref("Set.prototype.keys()")}}</dt>
+ <dd>É a mesma função que a função <strong><code>values()</code></strong> e retorna um novo objeto <code>Iterator</code> que contém os valores para cada elemento no objeto <code>Set</code>  em ordem de inserção.</dd>
+ <dt>{{jsxref("Set.prototype.values()")}}</dt>
+ <dd>Retorna um novo objeto <code>Iterator</code> que contém os <strong>values</strong> para cada elemento no objeto <code>Set</code>  em ordem de inserção.</dd>
+ <dt>{{jsxref("Set.prototype.@@iterator()", "Set.prototype[@@iterator]()")}}</dt>
+ <dd>Retorna um novo objeto <code>Iterator</code> que contém os <strong>values</strong> para cada elemento do objeto <code>Set</code> em ordem de inserção.</dd>
+</dl>
+
+<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('ES2015', '#sec-set.prototype', 'Set.prototype')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype', 'Set.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Set.prototype")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/set/values/index.html b/files/pt-br/web/javascript/reference/global_objects/set/values/index.html
new file mode 100644
index 0000000000..be96764668
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/set/values/index.html
@@ -0,0 +1,72 @@
+---
+title: Set.prototype.values()
+slug: Web/JavaScript/Reference/Global_Objects/Set/values
+translation_of: Web/JavaScript/Reference/Global_Objects/Set/values
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>values()</strong></code> retorna um novo objeto <code>Iterator</code> que contem os valores para cada elemento dentro do objeto <code>Set</code> por ordem de inserção.</p>
+
+<p>O método <strong><code>keys()</code></strong> é um alias desse método (por similaridade com os objetos {{jsxref("Map")}}); ele se comporta exatamente da mesma forma e retorna os <strong>valores</strong> dos elementos do <code>Set</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/set-prototype-values.html")}}</div>
+
+<p class="hidden">O código-fonte dos exemplos interativos a seguir estão em um repositório do GitHub. Se você quiser contribuir com os mesmos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e crie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>mySet</em>.values();
+</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um novo objeto <code><strong>Iterator</strong></code> condendo os valores de cada elemento contido no <code>Set</code>, por ordem de inserção.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_values()">Usando <code>values()</code></h3>
+
+<pre class="brush:js">var mySet = new Set();
+mySet.add('foo');
+mySet.add('bar');
+mySet.add('baz');
+
+var setIter = mySet.values();
+
+console.log(setIter.next().value); // "foo"
+console.log(setIter.next().value); // "bar"
+console.log(setIter.next().value); // "baz"</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('ES2015', '#sec-set.prototype.values', 'Set.prototype.values')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definições iniciais.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-set.prototype.values', 'Set.prototype.values')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browsers_compatíveis">Browsers compatíveis</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Set.values")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Set.prototype.entries()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html b/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html
new file mode 100644
index 0000000000..5a7700861c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/@@iterator/index.html
@@ -0,0 +1,84 @@
+---
+title: 'String.prototype[@@iterator]()'
+slug: Web/JavaScript/Reference/Global_Objects/String/@@iterator
+tags:
+  - Iterador
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/@@iterator
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>[@@iterator]()</code></strong> retorna um novo objeto <code>Iterator</code> que itera sobre os pontos de código do valor da String, retornando cada ponto de código como um valor String.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>[Symbol.iterator]</code></pre>
+
+<h3 id="Valor_de_Retorno">Valor de Retorno</h3>
+
+<p>Novo objeto <code>Iterator</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_iterator">Usando <code>[@@iterator]()</code></h3>
+
+<pre class="brush:js notranslate">var str = 'A\uD835\uDC68';
+
+var strIter = str[Symbol.iterator]();
+
+console.log(strIter.next().value); // "A"
+console.log(strIter.next().value); // "\uD835\uDC68"
+</pre>
+
+<h3 id="Usando_iterator_com_for..of">Usando <code>[@@iterator]()</code> com <code>for..of</code></h3>
+
+<pre class="brush:js notranslate">var str = 'A\uD835\uDC68B\uD835\uDC69C\uD835\uDC6A';
+
+for (var v of str) {
+  console.log(v);
+}
+// "A"
+// "\uD835\uDC68"
+// "B"
+// "\uD835\uDC69"
+// "C"
+// "\uD835\uDC6A"
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col"></th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype-@@iterator', 'String.prototype[@@iterator]()')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.@@iterator")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html b/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html
new file mode 100644
index 0000000000..99207cfb2d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/anchor/index.html
@@ -0,0 +1,76 @@
+---
+title: String.prototype.anchor()
+slug: Web/JavaScript/Reference/Global_Objects/String/anchor
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/anchor
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<div>O método <strong><code>anchor()</code></strong> cria uma string começando com uma tag inicial <code>&lt;a name="..."&gt;</code>, um texto e uma tag final <code>&lt;/a&gt;</code>.</div>
+
+<div class="blockIndicator warning">
+<p>Não use este método. Ao invés, use <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model">DOM APIs</a>. Além disso, a especificação HTML não permite mais que o elemento &lt;a&gt; tenha um atributo <strong>"name"</strong>, portanto, esse método nem mesmo cria uma tag válida.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.anchor(<var>name</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>name</code></dt>
+ <dd>Uma string que deve representar o valor do atributo <em><code>name</code>.</em></dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string começando com uma tag de início <em><code>&lt;a name="name"&gt;</code></em>, depois o valor da string e, em seguida, uma tag de fim <em><code>&lt;/a&gt;</code></em>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Não use este método. Ao invés, use <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model">DOM APIs</a>. Além disso, a especificação HTML não permite mais que o elemento <em><code>&lt;a&gt;</code></em> tenha um atributo <strong>"name"</strong>, portanto, esse método nem mesmo cria uma tag válida.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_anchor">Usando <code>anchor()</code></h3>
+
+<pre class="brush: js notranslate">const nome = 'Ricardo';
+console.log(nome.anchor('https://developer.mozilla.org/pt-BR/)');
+</pre>
+
+<p>irá retornar o seguinte código HTML:</p>
+
+<pre class="brush: html notranslate">'<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string">&lt;a name="<a class="url" href="https://developer.mozilla.org/pt-BR/" rel="noopener noreferrer" title="https://developer.mozilla.org/pt-BR/">https://developer.mozilla.org/pt-BR/</a>"&gt;Ricardo&lt;/a&gt;</span></span></span></span>'
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.anchor', 'String.prototype.anchor')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.anchor")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.link()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/big/index.html b/files/pt-br/web/javascript/reference/global_objects/string/big/index.html
new file mode 100644
index 0000000000..cbfea513f1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/big/index.html
@@ -0,0 +1,76 @@
+---
+title: String.prototype.big()
+slug: Web/JavaScript/Reference/Global_Objects/String/big
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/big
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <strong>big()</strong> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/big" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/big">&lt;big&gt;</a> fazendo com que o texto dentro dele seja exibido uma uma fonte maior.</p>
+
+<div class="note">
+<p><strong>Nota de uso:</strong> O elemento &lt;big&gt; foi removido no <a href="/en-US/docs/Web/Guide/HTML/HTML5">HTML5</a> e não deve mais ser usado. Em vez disso, web developers devem usar a <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size">propriedade CSS correspondente</a>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.big()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>big()</code> cria uma string dentro de uma tag <code>&lt;big&gt;</code>:<br>
+ <code>"&lt;big&gt;str&lt;/big&gt;"</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_big">Usando <code>big()</code></h3>
+
+<p>Os exemplos abaixo usam métodos do objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings">String </a>para alterar o tamanho de uma string:</p>
+
+<pre class="brush: js notranslate">var worldString = 'Olá, mundo';
+
+console.log(worldString.small());     // &lt;small&gt;Olá, mundo&lt;/small&gt;
+console.log(worldString.big());       // &lt;big&gt;Olá, mundo&lt;/big&gt;
+console.log(worldString.fontsize(7)); // &lt;fontsize=7&gt;Olá, Mundo&lt;/fontsize&gt;
+</pre>
+
+<p>Com o objeto <code>element.style</code> você pode selecionar o atributo <code>style</code> do elemento e manipulá-lo de forma mais genérica, por exemplo:</p>
+
+<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.fontSize = '2em';
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.big', 'String.prototype.big')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.big")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.fontsize()")}}</li>
+ <li>{{jsxref("String.prototype.small()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/blink/index.html b/files/pt-br/web/javascript/reference/global_objects/string/blink/index.html
new file mode 100644
index 0000000000..b6c77214bb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/blink/index.html
@@ -0,0 +1,71 @@
+---
+title: String.prototype.blink()
+slug: Web/JavaScript/Reference/Global_Objects/String/blink
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/blink
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code><strong>blink()</strong></code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink">&lt;blink&gt;</a> que faz uma string piscar.</p>
+
+<div class="warning">
+<p><strong>Aviso:</strong> A criação de textos que piscam é desaprovada por vários padrões de acessibilidade. O próprio elemento <code>&lt;blink&gt;</code> não é padrão e está obsoleto!</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.blink()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/blink">&lt;blink&gt;</a>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>blink()</code> cria uma string dentro de uma tag <code>&lt;blink&gt;</code>:<br>
+ <code>"&lt;blink&gt;str&lt;/blink&gt;"</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_blink">Usando <code>blink()</code></h3>
+
+<p>Os exemplos abaixo usam métodos do objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings">String </a>para alterar a formatação de uma string:</p>
+
+<pre class="brush: js notranslate">var worldString = 'Olá, mundo';
+
+console.log(worldString.blink());   // &lt;blink&gt;Olá, mundo&lt;/blink&gt;
+console.log(worldString.bold());    // &lt;b&gt;Olá, mundo&lt;/b&gt;
+console.log(worldString.italics()); // &lt;i&gt;Olá, mundo&lt;/i&gt;
+console.log(worldString.strike());  // &lt;strike&gt;Olá, mundo&lt;/strike&gt;</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.blink', 'String.prototype.blink')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.blink")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.bold()")}}</li>
+ <li>{{jsxref("String.prototype.italics()")}}</li>
+ <li>{{jsxref("String.prototype.strike()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/bold/index.html b/files/pt-br/web/javascript/reference/global_objects/string/bold/index.html
new file mode 100644
index 0000000000..bc34403734
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/bold/index.html
@@ -0,0 +1,68 @@
+---
+title: String.prototype.bold()
+slug: Web/JavaScript/Reference/Global_Objects/String/bold
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/bold
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code><strong>bold()</strong></code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b">&lt;b&gt;</a> que faz com que uma string seja exibida em negrito.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.bold()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/b">&lt;b&gt;</a> .</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>bold()</code> cria uma string dentro de uma tag <code>&lt;b&gt;</code>:<br>
+ <code>"&lt;b&gt;str&lt;/b&gt;"</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_bold">Usando <code>bold()</code></h3>
+
+<p>Os exemplos abaixo usam métodos do objeto <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String#M%C3%A9todos_gen%C3%A9ricos_de_Strings">String </a>para alterar a formatação de uma string:</p>
+
+<pre class="brush: js notranslate">var worldString = 'Olá, mundo';
+
+console.log(worldString.blink());   // &lt;blink&gt;Olá, mundo&lt;/blink&gt;
+console.log(worldString.bold());    // &lt;b&gt;Olá, mundo&lt;/b&gt;
+console.log(worldString.italics()); // &lt;i&gt;Olá, mundo&lt;/i&gt;
+console.log(worldString.strike());  // &lt;strike&gt;Olá, mundo&lt;/strike&gt;</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.bold', 'String.prototype.bold')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.bold")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.blink()")}}</li>
+ <li>{{jsxref("String.prototype.italics()")}}</li>
+ <li>{{jsxref("String.prototype.strike()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/charat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/charat/index.html
new file mode 100644
index 0000000000..87866ac56b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/charat/index.html
@@ -0,0 +1,290 @@
+---
+title: String.prototype.charAt()
+slug: Web/JavaScript/Reference/Global_Objects/String/charAt
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/charAt
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>charAt()</code></strong> retorna o caractere especificado a partir de uma string.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.charAt(<var>index</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>index</code></dt>
+ <dd>Um inteiro entre <code>0</code> e <code>str.length - 1</code>. Se nenhum índice for definido, <code>charAt()</code> usará <code>0</code> como índice.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string representando o caractere no índice especificado. Uma string vazia se o <strong><code>index</code> </strong>fornecido estiver fora do intervalo de índices da string <code>str</code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é <code>0</code><strong> </strong>(zero), e o índice do último caractere em uma string declarada como <code>stringName</code> é <code>stringName.length - 1</code>. Se o índice que você fornecer estiver fora do intervalo de índices da string, JavaScript retornará uma string vazia.</p>
+
+<p>Se nenhum índice for passado para <code>charAt()</code>, <code>0</code> será usado por padrão.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Mostrando_caracteres_em_diferente_localizações_em_uma_string">Mostrando caracteres em diferente localizações em uma string</h3>
+
+<p>O exemplo a seguir mostra caracteres em diferentes locais em uma string <code>"Brave new world"</code>:</p>
+
+<pre class="brush: js notranslate">var anyString = 'Brave new world';
+
+console.log("A letra no índice 0 é '" + anyString.charAt(0)   + "'");
+console.log("A letra no índice 1 é '" + anyString.charAt(1)   + "'");
+console.log("A letra no índice 2 é '" + anyString.charAt(2)   + "'");
+console.log("A letra no índice 3 é '" + anyString.charAt(3)   + "'");
+console.log("A letra no índice 4 é '" + anyString.charAt(4)   + "'");
+console.log("A letra no índice 99 é '" + anyString.charAt(999) + "'");
+</pre>
+
+<p>As linhas acima retornam o seguinte:</p>
+
+<pre class="brush: js notranslate">A letra no índice 0 é 'B'
+A letra no índice 1 é 'r'
+A letra no índice 2 é 'a'
+A letra no índice 3 é 'v'
+A letra no índice 4 é 'e'
+A letra no índice 99 é ''
+</pre>
+
+<h3 id="Obtendo_caracteres_inteiros">Obtendo caracteres inteiros</h3>
+
+<p>O seguinte código fornece um meio de garantir que passar por um loop de string sempre forneça um caractere inteiro, mesmo se a string contiver caracteres que não estão no <a href="https://pt.wikipedia.org/wiki/Plano_(Unicode)" title="https://pt.wikipedia.org/wiki/Plano_(Unicode)">Plano Multilíngue Básico</a>.</p>
+
+<pre class="brush: js notranslate">var str = 'A \uD87E\uDC04 Z'; // We could also use a non-BMP character directly
+for (var i = 0, chr; i &lt; str.length; i++) {
+  if ((chr = getWholeChar(str, i)) === false) {
+    continue;
+  }
+  // Adapt this line at the top of each loop, passing in the whole string and
+  // the current iteration and returning a variable to represent the
+  // individual character
+
+  console.log(chr);
+}
+
+function getWholeChar(str, i) {
+  var code = str.charCodeAt(i);
+
+  if (isNaN(code)) {
+    return ''; // Position not found
+  }
+  if (code &lt; 0xD800 || code &gt; 0xDFFF) {
+    return str.charAt(i);
+  }
+
+  // High surrogate (could change last hex to 0xDB7F to treat high private
+  // surrogates as single characters)
+  if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
+    if (str.length &lt;= (i + 1)) {
+      throw 'High surrogate without following low surrogate';
+    }
+    var next = str.charCodeAt(i + 1);
+      if (0xDC00 &gt; next || next &gt; 0xDFFF) {
+        throw 'High surrogate without following low surrogate';
+      }
+      return str.charAt(i) + str.charAt(i + 1);
+  }
+  // Low surrogate (0xDC00 &lt;= code &amp;&amp; code &lt;= 0xDFFF)
+  if (i === 0) {
+    throw 'Low surrogate without preceding high surrogate';
+  }
+  var prev = str.charCodeAt(i - 1);
+
+  // (could change last hex to 0xDB7F to treat high private
+  // surrogates as single characters)
+  if (0xD800 &gt; prev || prev &gt; 0xDBFF) {
+    throw 'Low surrogate without preceding high surrogate';
+  }
+  // We can pass over low surrogates now as the second component
+  // in a pair which we have already processed
+  return false;
+}
+</pre>
+
+<p>Em um ambiente ECMAScript 2016 que permite atribuição desestruturada, o seguinte código é uma alternativa mais sucinta e um pouco mais flexível, pois faz incremento para uma variável de incremento automaticamente (se o caractere justificar que seja um par substituto).</p>
+
+<pre class="brush: js notranslate">var str = 'A\uD87E\uDC04Z'; // We could also use a non-BMP character directly
+for (var i = 0, chr; i &lt; str.length; i++) {
+  [chr, i] = getWholeCharAndI(str, i);
+  // Adapt this line at the top of each loop, passing in the whole string and
+  // the current iteration and returning an array with the individual character
+  // and 'i' value (only changed if a surrogate pair)
+
+  console.log(chr);
+}
+
+function getWholeCharAndI(str, i) {
+  var code = str.charCodeAt(i);
+
+  if (isNaN(code)) {
+    return ''; // Position not found
+  }
+  if (code &lt; 0xD800 || code &gt; 0xDFFF) {
+    return [str.charAt(i), i]; // Normal character, keeping 'i' the same
+  }
+
+  // High surrogate (could change last hex to 0xDB7F to treat high private
+  // surrogates as single characters)
+  if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
+    if (str.length &lt;= (i + 1)) {
+      throw 'High surrogate without following low surrogate';
+    }
+    var next = str.charCodeAt(i + 1);
+      if (0xDC00 &gt; next || next &gt; 0xDFFF) {
+        throw 'High surrogate without following low surrogate';
+      }
+      return [str.charAt(i) + str.charAt(i + 1), i + 1];
+  }
+  // Low surrogate (0xDC00 &lt;= code &amp;&amp; code &lt;= 0xDFFF)
+  if (i === 0) {
+    throw 'Low surrogate without preceding high surrogate';
+  }
+  var prev = str.charCodeAt(i - 1);
+
+  // (could change last hex to 0xDB7F to treat high private surrogates
+  // as single characters)
+  if (0xD800 &gt; prev || prev &gt; 0xDBFF) {
+    throw 'Low surrogate without preceding high surrogate';
+  }
+  // Return the next character instead (and increment)
+  return [str.charAt(i + 1), i + 1];
+}
+</pre>
+
+<h3 id="Corrigindo_charAt_para_suportar_caracteres_não-Plano-Multilíngüe-Básico_PMB">Corrigindo <code>charAt()</code> para suportar caracteres não-Plano-Multilíngüe-Básico (PMB)</h3>
+
+<p>Embora o exemplo anterior possa ser mais útil para programas que devem suportar caracteres não BMP (uma vez que não exige que o chamador saiba onde qualquer caractere não BMP pode aparecer), no caso de desejar, na escolha de um caractere por índice, para tratar os pares substitutos em uma string como os caracteres únicos que eles representam, pode-se usar o seguinte:</p>
+
+<pre class="brush: js notranslate">function fixedCharAt(str, idx) {
+  var ret = '';
+  str += '';
+  var end = str.length;
+
+  var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  while ((surrogatePairs.exec(str)) != null) {
+    var li = surrogatePairs.lastIndex;
+    if (li - 2 &lt; idx) {
+      idx++;
+    } else {
+      break;
+    }
+  }
+
+  if (idx &gt;= end || idx &lt; 0) {
+    return '';
+  }
+
+  ret += str.charAt(idx);
+
+  if (/[\uD800-\uDBFF]/.test(ret) &amp;&amp; /[\uDC00-\uDFFF]/.test(str.charAt(idx + 1))) {
+    // Go one further, since one of the "characters" is part of a surrogate pair
+    ret += str.charAt(idx + 1);
+  }
+  return ret;
+}
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.4', 'String.prototype.charAt')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.charat', 'String.prototype.charAt')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.indexOf()")}}</li>
+ <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
+ <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
+ <li>{{jsxref("String.prototype.codePointAt()")}}</li>
+ <li>{{jsxref("String.prototype.split()")}}</li>
+ <li>{{jsxref("String.fromCodePoint()")}}</li>
+ <li><a href="https://mathiasbynens.be/notes/javascript-unicode">JavaScript has a Unicode problem – Mathias Bynens</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html
new file mode 100644
index 0000000000..67bbbac67d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/charcodeat/index.html
@@ -0,0 +1,213 @@
+---
+title: String.prototype.charCodeAt()
+slug: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
+tags:
+  - JavaScript
+  - Referencia
+  - String
+  - Unicode
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/charCodeAt
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>charCodeAt()</code></strong> retorna um número inteiro entre <code>0</code> e <code>65535</code> que representa a unidade de código UTF-16 no índice fornecido. A unidade de código UTF-16 corresponde ao ponto de código Unicode para pontos de códigos representáveis em uma única unidade de código UTF-16, mas também pode ser a primeira unidade de código de um par substituto não representável em uma única unidade de código UTF-16. Po exemplo: pontos de código Unicode  &gt; (0x10000). Se você quer o valor do ponto de código inteiro, use <strong><code>codePointAt</code></strong>().</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.charCodeAt(<em>index</em>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>index</code></dt>
+ <dd>Um inteiro maior ou igual a <code>0</code> e menor que o comprimento da string. Se não for um número, o padrão será <code>0</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um número representando o valor de unidade de código UTF-16 do caractere no índice fornecido. O valor {{jsxref("Global_Objects/NaN", "NaN")}} é retornado se o índice estiver fora do intervalo aceitável.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Os pontos de código Unicode variam de <code>0</code> a <code>1114111</code> (<code>0x10FFFF</code>). Os primeiros 128 pontos de código Unicode são uma correspondência direta da codificação de caracteres ASCII. (Para informações sobre Unicode, veja o <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Values,_variables,_and_literals" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Values,_variables,_and_literals">JavaScript Guide</a>.)</p>
+
+<div class="blockIndicator note">
+<p><strong>Nota</strong>: o <code>charCodeAt()</code> sempre retornará um valor menor do que <code>65536</code>. Isso ocorre pois os pontos de código mais altos são representados por um par de pseudo-caracteres "substitutos" (de menor valor) que são usados para compreender o caracter real.<br>
+ <br>
+ Por isso, para examinar (ou reproduzir) o caractere completo para valores de caracteres individuais de valor <code>65536</code> e acima, é necessário recuperar não apenas o <code>charCodeAt(<em>i</em>)</code>, mas também o <code>charCodeAt(<em>i</em>+1)</code> (como se examinando/reproduzindo a string com duas letras), ou usar o <code>codePointAt(<em>i</em>)</code>. Veja o exemplo 2 e 3 (abaixo).</p>
+</div>
+
+<p>Compatibilidade com versões anteriores: Em versões históricas (como JavaScript 1.2) o método <code>charCodeAt()</code> retorna um número indicando o valor de conjunto de códigos ISO-Latin-1 do caractere no dado índice. O conjunto de códigos ISO-Latin-1 varia de <code>0</code> a <code>255</code>. Os primeiros <code>128</code> (do <code>0</code> ao <code>127</code>) são uma correspondência direta ao conjunto de caracteres ASCII.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_charCodeAt">Usando <code>charCodeAt()</code></h3>
+
+<p>O exemplo a seguir retorna <code>65</code>, o valor Unicode para A.</p>
+
+<pre class="brush: js notranslate">'ABC'.charCodeAt(0); // retorna 65
+</pre>
+
+<h3 id="Corrigindo_o_charCodeAt_para_manipular_caracteres_de_Plano_Multilingual_não_Básico_se_sua_presença_na_string_é_desconhecida">Corrigindo o <code>charCodeAt()</code> para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida</h3>
+
+<p>Essa versão pode ser usada em loops <strong>for </strong>e afins quando não sabemos se caracteres de Plano Multilingual não Básico existem antes da posição do índice especificado.</p>
+
+<pre class="brush: js notranslate">function fixedCharCodeAt(str, idx) {
+  // ex. fixedCharCodeAt('\uD800\uDC00', 0); // 65536
+  // ex. fixedCharCodeAt('\uD800\uDC00', 1); // false
+  idx = idx || 0;
+  var code = str.charCodeAt(idx);
+  var hi, low;
+
+  // Substituto elevado (poderia mudar o último hex para 0xDB7F para tratar
+  // substitutos privados elevados como caracteres únicos)
+  if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
+    hi = code;
+    low = str.charCodeAt(idx + 1);
+    if (isNaN(low)) {
+      throw 'High surrogate not followed by low surrogate in fixedCharCodeAt()';
+    }
+    return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
+  }
+  if (0xDC00 &lt;= code &amp;&amp; code &lt;= 0xDFFF) { // Low surrogate
+    // Retornamos false para permitir os loops pularem essa iteração já que já deveria
+    //ter tratado os substitutos elevados acima, na iteração anterior
+    return false;
+    /*hi = str.charCodeAt(idx - 1);
+    low = code;
+    return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;*/
+  }
+  return code;
+}
+</pre>
+
+<h3 id="Corrigindo_o_charCodeAt_para_manipular_caracteres_de_Plano_Multilingual_não_Básico_se_sua_presença_na_string_é_desconhecida_2">Corrigindo o <code>charCodeAt()</code> para manipular caracteres de Plano Multilingual não Básico se sua presença na string é desconhecida</h3>
+
+<pre class="brush: js notranslate">function knownCharCodeAt(str, idx) {
+  str += '';
+  var code,
+      end = str.length;
+
+  var surrogatePairs = /[\uD800-\uDBFF][\uDC00-\uDFFF]/g;
+  while ((surrogatePairs.exec(str)) != null) {
+    var li = surrogatePairs.lastIndex;
+    if (li - 2 &lt; idx) {
+      idx++;
+    }
+    else {
+      break;
+    }
+  }
+
+  if (idx &gt;= end || idx &lt; 0) {
+    return NaN;
+  }
+
+  code = str.charCodeAt(idx);
+
+  var hi, low;
+  if (0xD800 &lt;= code &amp;&amp; code &lt;= 0xDBFF) {
+    hi = code;
+    low = str.charCodeAt(idx + 1);
+    // Vá um adiante, já que um dos "characters" é parte de um par substituto
+    return ((hi - 0xD800) * 0x400) + (low - 0xDC00) + 0x10000;
+  }
+  return code;
+}
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.5', 'String.prototype.charCodeAt')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.charcodeat', 'String.prototype.charCodeAt')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="sect1"></h2>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.fromCharCode()")}}</li>
+ <li>{{jsxref("String.prototype.charAt()")}}</li>
+ <li>{{jsxref("String.fromCodePoint()")}}</li>
+ <li>{{jsxref("String.prototype.codePointAt()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html
new file mode 100644
index 0000000000..c2b9caa273
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/codepointat/index.html
@@ -0,0 +1,143 @@
+---
+title: String.prototype.codePointAt()
+slug: Web/JavaScript/Reference/Global_Objects/String/codePointAt
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/codePointAt
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>codePointAt()</strong></code> retorna um número inteiro não negativo que é o valor do ponto de código Unicode.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-codepointat.html","shorter")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.codePointAt(<var>pos</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>pos</var></code></dt>
+ <dd>A posição de um elemento em uma string a partir do qual retorna o valor do ponto de código.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um número que representa o valor do ponto de código do caractere na <code>pos</code> fornecida. Se não houver nenhum elemento na <code>pos</code>, {{jsxref ("undefined")}} é retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se não houver nenhum elemento na posição especificada, é retornado o valor de {{jsxref ("undefined")}}. Se nenhum par substituto UTF-16 começar na <code>pos</code>, a unidade de código na <code>pos</code> será retornada.</p>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>O seguinte código cria no objeto global String a função <code>codePointAt()</code> conforme especificado em ECMAScript 2015 para navegadores sem suporte nativo:</p>
+
+<pre class="brush: js notranslate">/*! https://mths.be/codepointat v0.2.0 by @mathias */
+if (!String.prototype.codePointAt) {
+  (function() {
+    'use strict'; // needed to support `apply`/`call` with `undefined`/`null`
+    var defineProperty = (function() {
+      // IE 8 only supports `Object.defineProperty` on DOM elements
+      try {
+        var object = {};
+        var $defineProperty = Object.defineProperty;
+        var result = $defineProperty(object, object, object) &amp;&amp; $defineProperty;
+      } catch(error) {}
+      return result;
+    }());
+    var codePointAt = function(position) {
+      if (this == null) {
+        throw TypeError();
+      }
+      var string = String(this);
+      var size = string.length;
+      // `ToInteger`
+      var index = position ? Number(position) : 0;
+      if (index != index) { // better `isNaN`
+        index = 0;
+      }
+      // Account for out-of-bounds indices:
+      if (index &lt; 0 || index &gt;= size) {
+        return undefined;
+      }
+      // Get the first code unit
+      var first = string.charCodeAt(index);
+      var second;
+      if ( // check if it’s the start of a surrogate pair
+        first &gt;= 0xD800 &amp;&amp; first &lt;= 0xDBFF &amp;&amp; // high surrogate
+        size &gt; index + 1 // there is a next code unit
+      ) {
+        second = string.charCodeAt(index + 1);
+        if (second &gt;= 0xDC00 &amp;&amp; second &lt;= 0xDFFF) { // low surrogate
+          // https://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+          return (first - 0xD800) * 0x400 + second - 0xDC00 + 0x10000;
+        }
+      }
+      return first;
+    };
+    if (defineProperty) {
+      defineProperty(String.prototype, 'codePointAt', {
+        'value': codePointAt,
+        'configurable': true,
+        'writable': true
+      });
+    } else {
+      String.prototype.codePointAt = codePointAt;
+    }
+  }());
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_codePointAt">Usando <code>codePointAt()</code></h3>
+
+<pre class="brush: js notranslate">'ABC'.codePointAt(1)           // retorna 66
+'\uD800\uDC00'.codePointAt(0)  // retorna 65536
+
+'XYZ'.codePointAt(42)          // retorna undefined
+</pre>
+
+<h3 id="Criando_um_loop_com_codePointAt">Criando um loop com <code>codePointAt()</code></h3>
+
+<pre class="brush: js notranslate"><code class="md-code md-lang-javascript"><span class="md-code-keyword">for</span> (<span class="md-code-keyword">let</span> codePoint of <span class="md-code-string">'\ud83d\udc0e\ud83d\udc71\u2764'</span>) {
+   <span class="md-code-built_in">console</span>.log(codePoint<mark class="md-mark md-code-mark">.codePointAt(<span class="md-code-number">0</span>).toString(<span class="md-code-number">16</span>)</mark>)
+}
+// <span class="md-code-comment">retorna '1f40e', '1f471', '2764</span></code>'<code class="md-code md-lang-javascript"><span class="md-code-comment"> </span></code>
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.codepointat', 'String.prototype.codePointAt')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.codePointAt")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.fromCodePoint()")}}</li>
+ <li>{{jsxref("String.fromCharCode()")}}</li>
+ <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
+ <li>{{jsxref("String.prototype.charAt()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/concat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/concat/index.html
new file mode 100644
index 0000000000..1ea9f9eacf
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/concat/index.html
@@ -0,0 +1,138 @@
+---
+title: String.prototype.concat()
+slug: Web/JavaScript/Reference/Global_Objects/String/concat
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - concat()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/concat
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>concat()</code></strong> combina o texto de duas ou mais strings e retorna uma nova string.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.concat(<var>string2 </var>[, ...<var>stringN</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>string2...string<em>N</em></code></dt>
+ <dd>Strings para concatenar à <strong><code>string2</code></strong>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova string contendo a string original concatenada à string passada como parâmetro.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função <strong><code>concat()</code></strong> combina o texto de duas ou mais strings e retorna uma nova string. As alterações de texto de uma string não afetam a outra string.</p>
+
+<p>Se o argumento passado não for do tipo string, o mesmo será convertido em uma string antes de ser concatenado.</p>
+
+<h2 id="Performance">Performance</h2>
+
+<p>É extremamente recomendado o uso dos <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators" title="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators">operadores de atribuição</a> (<code>+</code>, <code>+=</code>) em detrimento do método <code>concat()</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_concat">Usando <code>concat()</code></h3>
+
+<p>O exemplo a seguir concatena uma string à outra string originando uma terceira string.</p>
+
+<pre class="brush: js notranslate">var hello = 'Olá, ';
+console.log(hello.concat('Kevin', ' tenha um bom dia.'));
+
+// retorna 'Olá, Kevin tenha um bom dia.'
+</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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.6', 'String.prototype.concat')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.concat', 'String.prototype.concat')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.concat()")}}</li>
+ <li>{{jsxref("Operators/Assignment_Operators", "Assignment operators", "", 1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html b/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html
new file mode 100644
index 0000000000..0e62545d41
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/endswith/index.html
@@ -0,0 +1,103 @@
+---
+title: String.prototype.endsWith()
+slug: Web/JavaScript/Reference/Global_Objects/String/endsWith
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - endsWith()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/endsWith
+---
+<div>{{JSRef}}</div>
+
+<div></div>
+
+<p>O método <strong><code>endsWith()</code></strong> indica se uma string termina com determinados caracteres, retornando <code>true</code> ou <code>false</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>str</var>.endsWith(s<var>tringSendoBuscada</var>[, <var>tamanho</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>stringSendoBuscada</code></dt>
+ <dd>Os caracteres a serem pesquisados no final da string.</dd>
+ <dt><code>tamanho</code></dt>
+ <dd>Opcional. Se fornecido, substitui o tamanho da string passada. Se omitido, o valor padrão é o tamanho da string.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p><strong><code>true</code></strong> se os caracteres passados forem encontrados no final da string. Do contrário, retorna <strong><code>false</code></strong>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Este método permite que você verifique se uma string termina ou não com determinados caracteres. Este método é case-sensitive.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_endsWith">Usando <code>endsWith()</code></h3>
+
+<pre class="brush: js notranslate">var str = 'Ser ou não ser, eis a questão';
+
+console.log(str.endsWith('questão')); // retorna true
+console.log(str.endsWith('ser'));     // retorna false
+console.log(str.endsWith('ser', 14)); // retorna true
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Este método foi adicionada na especificação ECMAScript 6 e talvez não esteja disponível em todos as implementações JavaScript ainda. No entanto, você pode criá-lo adicionando o seguinte código:</p>
+
+<pre class="brush: js notranslate">if (!String.prototype.endsWith)
+  String.prototype.endsWith = function(searchStr, Position) {
+      // This works much better than &gt;= because
+      // it compensates for NaN:
+      if (!(Position &lt; this.length))
+        Position = this.length;
+      else
+        Position |= 0; // round position
+      return this.substr(Position - searchStr.length,
+                         searchStr.length) === searchStr;
+  };
+</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-string.prototype.endswith', 'String.prototype.endsWith')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.endswith', 'String.prototype.endsWith')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.endsWith")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.startsWith()")}}</li>
+ <li>{{jsxref("String.prototype.includes()")}}</li>
+ <li>{{jsxref("String.prototype.indexOf()")}}</li>
+ <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html
new file mode 100644
index 0000000000..4a6004f05d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/fixed/index.html
@@ -0,0 +1,66 @@
+---
+title: String.prototype.fixed()
+slug: Web/JavaScript/Reference/Global_Objects/String/fixed
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - fixed()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/fixed
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <strong><code>fixed()</code></strong> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt">&lt;tt&gt;</a></code> que faz com que uma string seja exibida em uma fonte de densidade fixa.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.fixed()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string que representa o elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/tt">&lt;tt&gt;</a>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método<strong> </strong><code>fixed()</code> cria uma string dentro de uma tag <code>&lt;tt&gt;</code>:<br>
+ <code>"&lt;tt&gt;str&lt;/tt&gt;"</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_fixed">Usando <code>fixed()</code></h3>
+
+<p>O exemplo a seguir usa o método <code>fixed()</code> para alterar a formatação de uma string:</p>
+
+<pre class="brush: js notranslate">var worldString = 'Olá, mundo';
+console.log(worldString.fixed()); // "&lt;tt&gt;Olá, mundo&lt;/tt&gt;"
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.fixed', 'String.prototype.fixed')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.fixed")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.bold()")}}</li>
+ <li>{{jsxref("String.prototype.italics()")}}</li>
+ <li>{{jsxref("String.prototype.strike()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html
new file mode 100644
index 0000000000..aafc3074e9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/fontcolor/index.html
@@ -0,0 +1,84 @@
+---
+title: String.prototype.fontcolor()
+slug: Web/JavaScript/Reference/Global_Objects/String/fontcolor
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - fontcolor()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/fontcolor
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code>fontcolor()</code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font">&lt;font&gt;</a> que faz com que uma string seja exibida na cor especificada.</p>
+
+<div class="note">
+<p><strong>Nota de uso:</strong> O elemento <code>&lt;font&gt;</code> foi removido do <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5">HTML5</a> e não deve mais ser usado. Em vez disso, web developers devem usar a <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value">propriedade CSS correspondente</a>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.fontcolor(<var>color</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>color</code></dt>
+ <dd>Deve ser um string que expresse uma cor em formato hexadecimal ou o nome, em Inglês, de uma cor. Os nomes das cores estão listados na referência de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value#Palavras-chave_de_cores" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/color_value#Palavras-chave_de_cores">cores CSS</a>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font">&lt;font&gt;</a>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se você expressar uma cor em formato hexadecimal, deve usar o formato <code>rrggbb</code>. Por exemplo, os valores RGB hexadecimais para salmão são vermelho = FA, verde = 80 e azul = 72, portanto, o tripleto RGB para salmão é "FA8072".</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_fontcolor">Usando <code>fontcolor()</code></h3>
+
+<p>O exemplo a seguir usa o método <code>fontcolor()</code> para alterar a cor de uma string, produzindo uma string com a tag HTML <code>&lt;font&gt;</code>.</p>
+
+<pre class="brush: js notranslate">var worldString = 'Olá, mundo';
+
+console.log(worldString.fontcolor('red') +  ' está vermelho nesta linha');
+// '&lt;font color="red"&gt;Olá, mundo&lt;/font&gt; está vermelho nesta linha'
+
+console.log(worldString.fontcolor('FF00') + ' está vermelho em hexadecimal nesta linha');
+// '&lt;font color="FF00"&gt;Olá, mundo&lt;/font&gt; está vermelho em hexadecimal nesta linha'
+</pre>
+
+<p>Com o objeto <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style">element.style</a></code> você pode obter o atributo <code>style</code> do elemento e manipulá-lo de forma mais genérica, por exemplo:</p>
+
+<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.color = 'red';
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.fontcolor', 'String.prototype.fontcolor')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.fontcolor")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.fontsize()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html
new file mode 100644
index 0000000000..655a012b92
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/fontsize/index.html
@@ -0,0 +1,83 @@
+---
+title: String.prototype.fontsize()
+slug: Web/JavaScript/Reference/Global_Objects/String/fontsize
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - fontsize()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/fontsize
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code>fontsize()</code> cria um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font">&lt;font&gt;</a> que faz com que uma string seja exibida no tamanho da fonte especificada.</p>
+
+<div class="note">
+<p><strong>Nota de uso:</strong> O elemento <code>&lt;font&gt;</code> foi removido do <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/HTML5">HTML5</a> e não deve mais ser usado. Em vez disso, web developers devem usar a <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/CSS/font-size">propriedade CSS correspondente</a>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.fontsize(<var>size</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>size</code></dt>
+ <dd>Um número inteiro entre 1 e 7.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/font">&lt;font&gt;</a>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Ao especificar o tamanho como um inteiro, você define o tamanho da fonte do texto para um dos 7 tamanhos definidos. Ao especificar <code>size</code> como uma string como "-2", você ajusta o tamanho da fonte do texto em relação ao tamanho definido na tag <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/basefont" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/basefont">&lt;basefont&gt;</a>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_fontsize">Usando <code>fontsize()</code></h3>
+
+<p>O exemplo a seguir usa métodos do objeto global String para alterar o tamanho de uma string:</p>
+
+<pre class="brush: js notranslate">var worldString = 'Olá, mundo';
+
+console.log(worldString.small());     // &lt;small&gt;Olá, mundo&lt;/small&gt;
+console.log(worldString.big());       // &lt;big&gt;Olá, mundo&lt;/big&gt;
+console.log(worldString.fontsize(7)); // &lt;font size="7"&gt;Olá, mundo&lt;/fontsize&gt;
+</pre>
+
+<p>Com o objeto <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style">element.style</a></code> você pode obter o atributo <code>style</code> do elemento e manipulá-lo de forma mais genérica, por exemplo:</p>
+
+<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.fontSize = '0.7em';
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.fontsize', 'String.prototype.fontsize')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.fontsize")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.big()")}}</li>
+ <li>{{jsxref("String.prototype.small()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html
new file mode 100644
index 0000000000..23a8de8f44
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/fromcharcode/index.html
@@ -0,0 +1,142 @@
+---
+title: String.fromCharCode()
+slug: Web/JavaScript/Reference/Global_Objects/String/fromCharCode
+tags:
+  - JavaScript
+  - Referencia
+  - String
+  - UTF-16
+  - Unicode
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCharCode
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>String.fromCharCode()</code></strong> retorna uma string criada ao usar uma sequência específica de valores Unicode.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>String.fromCharCode(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>num1, ..., num<em>N</em></code></dt>
+ <dd>Uma sequência de números que devem ser valores UTF-16. O tamanho é entre <code>0</code> e <code>65535</code> (<code>0xFFFF</code>). Números maiores do que <code>0xFFFF</code> são desconsiderados. Nenhuma verificação de vadalida é realizada.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo os caracteres correspondentes à sequência de valores Unicode.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Esse método retorna uma string e não um objeto {{jsxref("String")}}.</p>
+
+<p>Como <code>fromCharCode() </code>é um método estático de {{jsxref("String")}}, você sempre o usará como <code>String.fromCharCode()</code>, ao invés de um método de um objeto {{jsxref("String")}} que você tenha criado.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_fromCharCode">Usando <code>fromCharCode()</code></h3>
+
+<p>O seguinte exemplo retorna a string "ABC".</p>
+
+<pre class="brush: js notranslate">String.fromCharCode(65, 66, 67);  // retorna "ABC"
+</pre>
+
+<h2 id="Fazendo-o_funcionar_com_valores_maiores">Fazendo-o funcionar com valores maiores</h2>
+
+<p>Embora os valores Unicode mais comuns possam ser representados com um número de 16 bits (como experado durante a padronização do JavaScript) e o fromCharCode() possa ser usado para retornar um único caracter dos valores mais comuns (por exemplo: valores UCS-2 que são os melhores subconjuntos do UTF-16 com os caractres mais comuns), a fim de resolver TODOS os valores Unicode legais (até 21 bits) o método fromCharCode() sozinho é inadequado. Como os caracteres de ponto de código mais alto usam 2 (valor menor) numeros "substitutos" para formar um único caracter, {{jsxref("String.fromCodePoint()")}} (parte do padrão ES2015) pode ser usado para retornar tal par e ainda representar adequadamente esses caracteres de valores altos.</p>
+
+<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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.3.2', 'StringfromCharCode')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.fromcharcodes', 'String.fromCharCode')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.fromCodePoint()")}}</li>
+ <li>{{jsxref("String.prototype.charAt()")}}</li>
+ <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
+ <li>{{jsxref("String.prototype.codePointAt()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html b/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html
new file mode 100644
index 0000000000..f8b2bfbf7d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/fromcodepoint/index.html
@@ -0,0 +1,213 @@
+---
+title: String.fromCodePoint()
+slug: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint
+tags:
+  - JavaScript
+  - Referencia
+  - String
+  - UTF-16
+  - Unicode
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/fromCodePoint
+---
+<div>{{JSRef}}</div>
+
+<p>O método estático <strong>String.fromCodePoint()</strong> retorna uma seqüência de caracteres criado usando a seqüência especificada de pontos de código.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox notranslate"><code>String.fromCodePoint(<var>num1</var>[, ...[, <var>numN</var>]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>num1, ..., num<em>N</em></code></dt>
+ <dd>Uma sequência de pontos de código.</dd>
+</dl>
+
+<h3 id="Exceções">Exceções</h3>
+
+<dl>
+ <dt>{{jsxref("RangeError")}}</dt>
+ <dd>
+ <p>O {{jsxref("RangeError")}} é lançado se um ponto de código Unicode inválido é dado (por exemplo, "RangeError: NaN não é um ponto de código válido").</p>
+ </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Como o fromCodePoint() é um método estático do {{jsxref("String")}}, você sempre vai chamar esse método como <strong>String.fromCodePoint()✔</strong> em vez de usá-lo como um método de uma string que você criar, como <strong>"minha string".fromCodePoint()❌</strong>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_fromCodePoint">Usando <code>fromCodePoint()</code></h3>
+
+<pre class="brush: js notranslate">String.fromCodePoint(42);       // "*"
+String.fromCodePoint(65, 90);   // "AZ"
+String.fromCodePoint(0x404);    // "\u0404"
+String.fromCodePoint(0x2F804);  // "\uD87E\uDC04"
+String.fromCodePoint(194564);   // "\uD87E\uDC04"
+String.fromCodePoint(0x1D306, 0x61, 0x1D307) // "\uD834\uDF06a\uD834\uDF07"
+
+String.fromCodePoint('_');      // RangeError
+String.fromCodePoint(Infinity); // RangeError
+String.fromCodePoint(-1);       // RangeError
+String.fromCodePoint(3.14);     // RangeError
+String.fromCodePoint(3e-2);     // RangeError
+String.fromCodePoint(NaN);      // RangeError
+</pre>
+
+<pre class="brush: js notranslate">// String.fromCharCode() alone cannot get the character at such a high code point
+// The following, on the other hand, can return a 4-byte character as well as the
+// usual 2-byte ones (i.e., it can return a single character which actually has
+// a string length of 2 instead of 1!)
+console.log(String.fromCodePoint(0x2F804)); // or 194564 in decimal
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>O método <strong>String.fromCodePoint</strong>  foi adicionado ao padrão ECMAScript na versão 6 e pode não ser suportado em todos os navegadores da Web ou em todos os ambientes ainda. <span class="notranslate"> Use o código abaixo para um polyfill:</span></p>
+
+<pre class="brush: js notranslate">/*! http://mths.be/fromcodepoint v0.1.0 by @mathias */
+if (!String.fromCodePoint) {
+  (function() {
+    var defineProperty = (function() {
+      // IE 8 only supports `Object.defineProperty` on DOM elements
+      try {
+        var object = {};
+        var $defineProperty = Object.defineProperty;
+        var result = $defineProperty(object, object, object) &amp;&amp; $defineProperty;
+      } catch(error) {}
+      return result;
+    }());
+    var stringFromCharCode = String.fromCharCode;
+    var floor = Math.floor;
+    var fromCodePoint = function() {
+      var MAX_SIZE = 0x4000;
+      var codeUnits = [];
+      var highSurrogate;
+      var lowSurrogate;
+      var index = -1;
+      var length = arguments.length;
+      if (!length) {
+        return '';
+      }
+      var result = '';
+      while (++index &lt; length) {
+        var codePoint = Number(arguments[index]);
+        if (
+          !isFinite(codePoint) ||       // `NaN`, `+Infinity`, or `-Infinity`
+          codePoint &lt; 0 ||              // not a valid Unicode code point
+          codePoint &gt; 0x10FFFF ||       // not a valid Unicode code point
+          floor(codePoint) != codePoint // not an integer
+        ) {
+          throw RangeError('Invalid code point: ' + codePoint);
+        }
+        if (codePoint &lt;= 0xFFFF) { // BMP code point
+          codeUnits.push(codePoint);
+        } else { // Astral code point; split in surrogate halves
+          // http://mathiasbynens.be/notes/javascript-encoding#surrogate-formulae
+          codePoint -= 0x10000;
+          highSurrogate = (codePoint &gt;&gt; 10) + 0xD800;
+          lowSurrogate = (codePoint % 0x400) + 0xDC00;
+          codeUnits.push(highSurrogate, lowSurrogate);
+        }
+        if (index + 1 == length || codeUnits.length &gt; MAX_SIZE) {
+          result += stringFromCharCode.apply(null, codeUnits);
+          codeUnits.length = 0;
+        }
+      }
+      return result;
+    };
+    if (defineProperty) {
+      defineProperty(String, 'fromCodePoint', {
+        'value': fromCodePoint,
+        'configurable': true,
+        'writable': true
+      });
+    } else {
+      String.fromCodePoint = fromCodePoint;
+    }
+  }());
+}
+</pre>
+
+<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>{{SpecName('ES6', '#sec-string.fromcodepoint', 'String.fromCodePoint')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>
+    <p>{{CompatChrome("41")}}</p>
+   </td>
+   <td>{{CompatGeckoDesktop("29")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera("28")}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("29")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.fromCharCode()")}}</li>
+ <li>{{jsxref("String.prototype.charAt()")}}</li>
+ <li>{{jsxref("String.prototype.codePointAt()")}}</li>
+ <li>{{jsxref("String.prototype.charCodeAt()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/includes/index.html b/files/pt-br/web/javascript/reference/global_objects/string/includes/index.html
new file mode 100644
index 0000000000..c76b927cf3
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/includes/index.html
@@ -0,0 +1,108 @@
+---
+title: String.prototype.includes()
+slug: Web/JavaScript/Reference/Global_Objects/String/includes
+tags:
+  - ES6
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/includes
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong>includes()</strong> determina se um conjunto de caracteres pode ser encontrado dentro de outra string, retornando <code>true</code> ou <code>false</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.includes(<var>searchString</var>[, <var>position</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>searchString</code></dt>
+ <dd>É o conjunto de caracteres que será pesquisado dentro desta string.</dd>
+ <dt><code>position</code></dt>
+ <dd>Opcional. É um número inteiro que indica por onde a busca iniciará, referente ao índice da string a ser pesquisada. O valor padrão é 0.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p><code>true</code> se o conjunto de caracteres for encontrado em algum lugar dentro da string sendo pesquisada. Do contrário, retorna <code>false</code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Este método permite conferir se uma string contém um determinado conjunto de caracteres.</p>
+
+<h3 id="Case-sensitivity">Case-sensitivity</h3>
+
+<p>O método <code>includes()</code> é case sensitive. Por exemplo, a seguinte expressão retorna <code>false</code>:</p>
+
+<pre class="brush: js notranslate">'Bandeira do Brasil'.includes('brasil'); // retorna false
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_includes">Utilizando <code>includes()</code></h3>
+
+<pre class="brush: js notranslate">var str = 'Ser, ou não ser, eis a questão.';
+
+console.log(str.includes('Ser'));         // true
+console.log(str.includes('questão'));     // true
+console.log(str.includes('não existe'));  // false
+console.log(str.includes('ser', 1));      // true
+console.log(str.includes('SER'));         // false
+</pre>
+
+<h2 id="Implementação">Implementação</h2>
+
+<p>Este método foi adicionado à especificação ECMAScript 6 e pode não estar disponível em todas as implementações JavaScript. No entanto, você pode facilmente implementar este método:</p>
+
+<pre class="brush: js notranslate">if (!String.prototype.includes) {
+  String.prototype.includes = function() {'use strict';
+    return String.prototype.indexOf.apply(this, arguments) !== -1;
+  };
+}
+
+</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-string.prototype.includes', 'String.prototype.includes')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{Compat("javascript.builtins.String.includes")}}</div>
+
+<h2 id="String.prototype.contains">String.prototype.contains</h2>
+
+<p>No Firefox 18 - 39, o nome deste método era <code>contains()</code>. Ele foi renomeado para <code>includes()</code> no {{bug(1102219)}} devido ao seguinte motivo:</p>
+
+<p>Foi <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=789036">reportado</a> que alguns websites que utilizam MooTools 1.2 não funcionavam no Firefox 17. Esta versão do MooTools verifica se <code>String.prototype.contains()</code> existe e, se não existir, MooTools adiciona sua própria função. Com a implementação desta função no Firefox 17, o comportamento desta validação mudou de uma forma que códigos baseados na implementação da função <code>String.prototype.contains()</code> do MooTools parassem de funcionar. Como resultado, esta mudança foi <a href="https://hg.mozilla.org/releases/mozilla-aurora/rev/086db97198a8">desabilitada</a> no Firefox 17 e <code>String.prototype.contains()</code> foi disponibilizada na versão seguinte, no Firefox 18.</p>
+
+<p>MooTools 1.3 força sua própria versão do <code>String.prototype.contains()</code>, portanto websites baseados nela não devem parar de funcionar. No entanto, você deve notar que <a href="http://mootools.net/core/docs/1.3.2/Types/String#String-method:-contains">a assinatura do MooTools 1.3</a> e a assinatura ECMAScript 6 diferem (no segundo argumento). Posteriormente, <a href="https://github.com/mootools/mootools-core/blob/master/Docs/Types/String.md#note">MooTools 1.5+ mudou sua assinatura para o padrão ES6.</a></p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.includes()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("TypedArray.prototype.includes()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("String.prototype.indexOf()")}}</li>
+ <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
+ <li>{{jsxref("String.prototype.startsWith()")}} {{experimental_inline}}</li>
+ <li>{{jsxref("String.prototype.endsWith()")}} {{experimental_inline}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/index.html b/files/pt-br/web/javascript/reference/global_objects/string/index.html
new file mode 100644
index 0000000000..e7ab10819b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/index.html
@@ -0,0 +1,338 @@
+---
+title: String
+slug: Web/JavaScript/Reference/Global_Objects/String
+tags:
+  - JavaScript
+  - Reference
+  - String
+translation_of: Web/JavaScript/Reference/Global_Objects/String
+---
+<p>{{JSRef("Global_Objects", "String")}}</p>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O objeto global <strong><code>String</code></strong>  é um construtor para <strong>strings,</strong> ou uma sequência de caracteres.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<p>As formas literais de declaração de <em>String</em>  são:</p>
+
+<pre class="syntaxbox">'string text'
+"string text"
+"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어"</pre>
+
+<p>Além da forma regular, de caracteres<em> </em>de impressão, caracteres especiais podem ser codificados usando a <em>escape notation </em>(notação com barra invertida):</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Codigo</th>
+   <th scope="col">Saida</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>\0</td>
+   <td>o  caractere NULL</td>
+  </tr>
+  <tr>
+   <td>\'</td>
+   <td>aspas simples</td>
+  </tr>
+  <tr>
+   <td>\"</td>
+   <td>aspas duplas</td>
+  </tr>
+  <tr>
+   <td>\\</td>
+   <td>barra invertida</td>
+  </tr>
+  <tr>
+   <td>\n</td>
+   <td>nova linha</td>
+  </tr>
+  <tr>
+   <td>\r</td>
+   <td>carriage return</td>
+  </tr>
+  <tr>
+   <td>\v</td>
+   <td>tab vertical</td>
+  </tr>
+  <tr>
+   <td>\t</td>
+   <td>tab</td>
+  </tr>
+  <tr>
+   <td>\b</td>
+   <td>backspace</td>
+  </tr>
+  <tr>
+   <td>\f</td>
+   <td>form feed</td>
+  </tr>
+  <tr>
+   <td>\uXXXX</td>
+   <td>unicode codepoint</td>
+  </tr>
+  <tr>
+   <td>\xXX</td>
+   <td>the Latin-1 character</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Ou, usando o objeto global <code>String</code> diretamente:</p>
+
+<pre class="syntaxbox">String(thing)
+new String(thing)</pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>thing</code></dt>
+ <dd>Qualquer coisa a ser convertida para uma string.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Strings são úteis para guardar dados que podem ser representados em forma de texto. Uma das operações mais usadas nas <strong>strings</strong> é checar seu {{jsxref("String.length", "tamanho")}}, para construir e concatená-las  usando <a href="/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">os operadores</a> <a href="/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">+ e +=, </a>checando pela existência ou posição de <em>substrings</em> com o método {{jsxref("String.indexOf", "indexOf")}} , ou extrair <em>substrings</em> com o método {{jsxref("String.substring", "substring")}}.</p>
+
+<h3 id="Character_access" name="Character_access">Acesso à caractere</h3>
+
+<p>Há duas maneiras de acessar um <span class="st">caractere </span>individual em uma string. A primeira é o método {{jsxref("String.charAt", "charAt")}}:</p>
+
+<pre class="brush: js">return 'cat'.charAt(1); // returns "a"
+</pre>
+
+<p>A outra maneira (introduzido no ECMAScript 5) consiste em tratar a string como um objeto Array-like, onde os caráteres individuais correspondem a um índice numérico:</p>
+
+<pre class="brush: js">return 'cat'[1]; // returns "a"
+</pre>
+
+<p>Para acesso de caracteres usando uma notação de colchetes, tentando deletar ou designar um valor a estas propriedades não haverá sucesso. As propriedades envolvidas não são nem escritas ou configuráveis. (Veja {{jsxref("Object.defineProperty")}} para mais informações.)</p>
+
+<h3 id="Comparing_strings" name="Comparing_strings">Comparando strings</h3>
+
+<p>Desenvolvedores de C têm a função strcmp() para comparar strings. No JavaScript, basta usar o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">maior que e menor que</a>:</p>
+
+<pre class="brush: js">var a = "a";
+var b = "b";
+if (a &lt; b) // verdadeiro
+  print(a + " é menor que " + b);
+else if (a &gt; b)
+  print(a + " é maior que " + b);
+else
+  print(a + " e " + b + " são iguais.");
+</pre>
+
+<p>Um resultado similar pode ser alcançado usando o método  {{jsxref("String.localeCompare", "localeCompare")}} herdado pelas instâncias de <code>String</code>.</p>
+
+<h3 id="Distinção_entre_String_primitiva_e_objetos_String">Distinção entre String primitiva e objetos String</h3>
+
+<p>Note que o JavaScript distingue entre objetos String e valores de string primitivas. (O mesmo é válido para {{jsxref("Global_Objects/Boolean", "Boolean")}} e {{jsxref("Global_Objects/Number", "Numbers")}}.)</p>
+
+<p>Strings literais (definidas por aspas duplas ou aspas simples) e strings retornadas da chamada da função String fora do contexto de uma função construtora (sem o uso da palavra chave <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a>) são strings primitivas. O JavaScript converte automaticamente strings primitivas para objetos do tipo String, por isso é possível utilizar os métodos do objeto String através de strings primitivas. Em contextos onde um método é invocado de uma string primitiva ou uma propriedade é procurada, o JavaScript irá criar um objeto com a string primitiva e executar o método ou acessar a propriedade procurada.</p>
+
+<pre class="brush: js">var s_prim = "foo";
+var s_obj = new String(s_prim);
+
+console.log(typeof s_prim); // Loga "string"
+console.log(typeof s_obj);  // Loga "object"
+</pre>
+
+<p>String primitivas e objetos <code>String</code> também dão resultados diferentes quando usado {{jsxref("Global_Objects/eval", "eval")}}. Primitivas passadas para <code>eval</code> são tratadas como código fonte; Objetos <code>String</code> são tratados como todos os outros objetos são, retornando o objeto. Por exemplo:</p>
+
+<pre class="brush: js">s1 = "2 + 2";               // cria uma string primitiva
+s2 = new String("2 + 2");   // cria um objeto de String
+console.log(eval(s1));      // retorna o número 4
+console.log(eval(s2));      // retorna a string "2 + 2"
+</pre>
+
+<p>Por estas razões, o código pode quebrar quando encontra objetos <code>String</code> quando espera na verdade uma string primitiva, apesar de que geralmente autores não precisam se preocupar com a distinção.</p>
+
+<p>Um objeto <code>String</code> pode ser convertido sempre para sua contraparte primitiva com o método {{jsxref("String.valueOf", "valueOf")}}.</p>
+
+<pre class="brush: js">console.log(eval(s2.valueOf())); // retorna o número 4
+</pre>
+
+<div class="note"><strong>Note:</strong> Para uma outra possível abordagem para strings em JavaScript, favor ler o artigo sobre <a href="/en-US/docs/Web/JavaScript/Typed_arrays/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code> – a C-like representation of strings based on typed arrays</a>.</div>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("String.prototype")}}</dt>
+ <dd>Permite a adição de propriedades a um objeto String.</dd>
+</dl>
+
+<div>{{jsOverrides("Function", "Properties", "prototype")}}</div>
+
+<h2 id="Methods" name="Methods">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("String.fromCharCode()")}}</dt>
+ <dd>Retorna uma string criada usando a sequência especificada de valores Unicode.</dd>
+ <dt>{{jsxref("String.fromCodePoint()")}} {{experimental_inline}}</dt>
+ <dd>Retorna uma string criada usando a sequência especificada de posições de código.</dd>
+</dl>
+
+<div>{{jsOverrides("Function", "Methods", "fromCharCode", "fromCodePoint")}}</div>
+
+<h2 id="Métodos_genéricos_de_Strings"><code>Métodos genéricos de Strings</code></h2>
+
+<p>Métodos de instância <code>String</code> também estão disponíveis no Firefox a partir de JavaScript 1.6 (embora não faça parte dos padrões ECMAScript) no objeto String para aplicar métodos String a qualquer objeto:</p>
+
+<pre class="brush: js">var num = 15;
+alert(String.replace(num, /5/, '2'));
+</pre>
+
+<p class="brush: js"><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array#Array_generic_methods">Genéricos</a> também estão disponíveis em métodos {{jsxref("Global_Objects/Array", "Array")}}.</p>
+
+<p class="brush: js">O seguinte é uma implementação para fornecer suporte a navegadores sem suporte:</p>
+
+<pre class="brush: js">/*globals define*/
+// Assume que todos os métodos de instância String fornecidos
+// já presentes (podem ser usadas implementações para este se não disponível)
+(function () {
+    'use strict';
+
+    var i,
+        // Nós também poderíamos construir o array de métodos com os seguintes,
+        // mas o método getOwnPropertyNames() não é implementável:
+        // Object.getOwnPropertyNames(String).filter(function (methodName)
+        //  {return typeof String[methodName] === 'function'});
+        methods = [
+            'quote', 'substring', 'toLowerCase', 'toUpperCase', 'charAt',
+            'charCodeAt', 'indexOf', 'lastIndexOf', 'startsWith', 'endsWith',
+            'trim', 'trimLeft', 'trimRight', 'toLocaleLowerCase',
+            'toLocaleUpperCase', 'localeCompare', 'match', 'search',
+            'replace', 'split', 'substr', 'concat', 'slice'
+        ],
+        methodCount = methods.length,
+        assignStringGeneric = function (methodName) {
+            var method = String.prototype[methodName];
+            String[methodName] = function (arg1) {
+                return method.apply(arg1, Array.prototype.slice.call(arguments, 1));
+            };
+        };
+
+    for (i = 0; i &lt; methodCount; i++) {
+        assignStringGeneric(methods[i]);
+    }
+}());
+</pre>
+
+<h2 id="Instâncias_de_String">Instâncias de <code>String</code></h2>
+
+<h3 id="Propriedades">Propriedades</h3>
+
+<p>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Propriedades')}}</p>
+
+<h3 id="Métodos">Métodos</h3>
+
+<h4 id="Métodos_não_relacionados_ao_HTML">Métodos não relacionados ao HTML</h4>
+
+<p>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Métodos_não_relacionados_ao_HTML')}}</p>
+
+<h4 id="Métodos_de_envoltório_HTML">Métodos de envoltório HTML</h4>
+
+<p>{{page('/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Métodos_de_envoltório_HTML')}}</p>
+
+<h2 id="String_instances" name="String_instances">Exemplos</h2>
+
+<h3 id="Conversão_de_String">Conversão de String</h3>
+
+<p>É possível usar <code>String</code> como uma alternativa "mais segura" {{jsxref("String.toString", "toString")}}, como embora normalmente ainda chama o <code>toString</code> subjacente, também funciona para <code>null</code> e <code>undefined</code>. Por exemplo:</p>
+
+<pre class="brush: js">var outputStrings = [];
+for (let i = 0, n = inputValues.length; i &lt; n; ++i) {
+  outputStrings.push(String(inputValues[i]));
+}
+</pre>
+
+<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>Definições iniciais.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string-objects', 'String')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>0.2</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/API/DOMString" title="/en-US/docs/Web/API/DOMString">DOMString</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays/StringView" title="/en-US/docs/Web/JavaScript/Typed_arrays/StringView"><code>StringView</code> – a C-like representation of strings based on typed arrays</a></li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/API/DOMString/Binary">Binary strings</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html b/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html
new file mode 100644
index 0000000000..fc62ad78a0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/indexof/index.html
@@ -0,0 +1,158 @@
+---
+title: String.prototype.indexOf()
+slug: Web/JavaScript/Reference/Global_Objects/String/indexOf
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - indexOf()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf
+---
+<p>{{JSRef("Global_Objects", "String")}}</p>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O método <code>indexOf()</code> retorna o índice da primeira ocorrência do valor fornecido em searchValue, começando a busca a partir de <code>fromIndex</code>. Retorna <code>-1</code> se o valor não for encontrado.</p>
+
+<div class="blockIndicator note">
+<p><strong>Nota:</strong> Para o método de Array, veja {{jsxref("Array.prototype.indexOf()")}}.</p>
+</div>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><em>str</em>.indexOf(<em>searchValue</em>[, <em>fromIndex</em>]</code>)</pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>searchValue</code></dt>
+ <dd>Uma string representando o valor a ser buscado. Se nenhuma string for fornecida explicitamente, <code>searchValue</code> terá o valor de <code>undefined</code>, e esse valor será buscado na string atual. Por exemplo, <code>'undefined'.indexOf()</code> retornará <code>0</code>, já que <code>undefined</code> é encontrado na posição <code>0</code>. Já <code>'undefine'.indexOf()</code> retornará <code>-1</code>, já que <code>undefined</code> não pôde ser encontrado.</dd>
+ <dt><code>fromIndex</code></dt>
+ <dd>Um número inteiro representando um índice da string original a partir da qual a busca deve começar. Por padrão é <code>0</code>. Se <code>fromIndex &lt; 0</code>, a string toda é percorrida (equivale a passar 0). Se <code>fromIndex</code> <code>&gt;=</code> <code>str.length</code>, o método retornará <code>-1</code>, já que a busca será iniciada após o final da string.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O índice da primeira ocorrência de <em>searchValue</em>, ou <code>-1</code> se não for encontrado.</p>
+
+<p>Uma string vazia no <em>searchValue</em> produz resultados estranhos. Sem <code>fromIndex</code>, ou com qualquer <code>fromIndex</code> menor que o comprimento da string, o valor retornado é o próprio <code>fromIndex</code>:</p>
+
+<pre class="brush: js line-numbers language-js notranslate"><code class="language-js"><span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">)</span> <span class="comment token">// retorna 0</span>
+<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">0</span><span class="punctuation token">)</span> <span class="comment token">// retorna 0</span>
+<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">3</span><span class="punctuation token">)</span> <span class="comment token">// retorna 3</span>
+<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">8</span><span class="punctuation token">)</span> <span class="comment token">// retorna 8</span></code></pre>
+
+<p>Entretanto, com qualquer <code>fromIndex</code> igual ou maior que o comprimento da string, o valor retornado é o comprimento da string:</p>
+
+<pre class="brush: js line-numbers language-js notranslate"><code class="language-js"><span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">11</span><span class="punctuation token">)</span> <span class="comment token">// retorna 10</span>
+<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">13</span><span class="punctuation token">)</span> <span class="comment token">// retorna 10</span>
+<span class="string token">'Olá, mundo'</span><span class="punctuation token">.</span><span class="function token">indexOf</span><span class="punctuation token">(</span><span class="string token">''</span><span class="punctuation token">,</span> <span class="number token">22</span><span class="punctuation token">)</span> <span class="comment token">// retorna 10</span></code></pre>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é <code>0</code>, e o índice do último caractere de uma string chamada <code>stringName</code> é <code>stringName.length - 1</code>.</p>
+
+<pre class="brush: js notranslate">"Blue Whale".indexOf("Blue");     // retorna  0
+"Blue Whale".indexOf("Whale");    // retorna  5
+"Blue Whale".indexOf("Blute");    // retorna -1
+"Blue Whale".indexOf("Whale", 0); // retorna  5
+"Blue Whale".indexOf("Whale", 5); // retorna  5
+"Blue Whale".indexOf("Whale", 7); // retorna -1
+"Blue Whale".indexOf("");         // retorna  0
+"Blue Whale".indexOf("", 9);      // retorna  9
+"Blue Whale".indexOf("", 10);     // retorna 10
+"Blue Whale".indexOf("", 11);     // retorna 10</pre>
+
+<h3 id="Verificando_ocorrências">Verificando ocorrências</h3>
+
+<p>Note que um retorno <code>0</code> não implica em <code>true</code>, e <code>-1</code> não implica em <code>false</code>. Portanto, a maneira correta de se verificar se uma string específica está contida em outra string seria:</p>
+
+<pre class="brush: js notranslate">"Blue Whale".indexOf("Blue") !== -1; // true
+"Blue Whale".indexOf("Bloe") !== -1; // false</pre>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Using_indexOf_and_lastIndexOf" name="Example:_Using_indexOf_and_lastIndexOf">Usando <code>indexOf()</code></h3>
+
+<p>O exemplo a seguir usa <code>indexOf()</code> para localizar valores dentro da string "<code>Brave new world</code>".</p>
+
+<pre class="brush: js notranslate">var anyString = "Brave new world";
+
+console.log("O índice do primeiro w partindo do começo é " + anyString.indexOf("w"));
+// Exibe 8
+
+console.log("O índice de 'new' partindo do começo é " + anyString.indexOf("new"));
+// Exibe 6
+</pre>
+
+<h3 id="Example_indexOf_and_case-sensitivity" name="Example:_indexOf_and_case-sensitivity"><code>indexOf()</code> e sensibilidade a maiúsculas e minúsculas</h3>
+
+<p>O exemplo a seguir define duas variáveis string. Ambas contém a mesma string, exceto que a segunda string tem letras maiúsculas. O primeiro método {{domxref("console.log()")}} exibe <code>19</code>. Porém, como o método <code>indexOf</code> é sensível a letras maiúsculas e minúsculas, a string <code>"cheddar"</code> não é encontrada em <code>myCapString</code>, portanto, o segundo método {{domxref("console.log()")}} exibe <code>-1</code>.</p>
+
+<pre class="brush: js notranslate">var myString    = "brie, pepper jack, cheddar";
+var myCapString = "Brie, Pepper Jack, Cheddar";
+
+console.log('myString.indexOf("cheddar") é ' + myString.indexOf("cheddar"));
+// Exibe 19
+console.log('myCapString.indexOf("cheddar") é ' + myCapString.indexOf("cheddar"));
+// Exibe -1</pre>
+
+<h3 id="Example_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string" name="Example:_Using_indexOf_to_count_occurrences_of_a_letter_in_a_string">Usando <code>indexOf()</code> para contar as ocorrências de uma letra numa string</h3>
+
+<p>O exemplo a seguir atribui à variável <code>count</code> o número de ocorrências da letra <code>x</code> na string <code>str</code>:</p>
+
+<pre class="brush: js notranslate">const str = 'Serx ou não ser, eisx a questão'
+count = 0;
+pos = str.indexOf("x"); // retorna 3
+
+while ( pos != -1 ) {
+   count++;
+   pos = str.indexOf( "x", pos + 1 /* o mesmo que 3 + 1 */ );
+}
+
+console.log(count);</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p>{{Compat("javascript.builtins.String.indexOf")}}</p>
+
+<h2 id="See_also" name="See_also"></h2>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.charAt()")}}</li>
+ <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
+ <li>{{jsxref("String.prototype.includes()")}}</li>
+ <li>{{jsxref("String.prototype.split()")}}</li>
+ <li>{{jsxref("Array.prototype.indexOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/italics/index.html b/files/pt-br/web/javascript/reference/global_objects/string/italics/index.html
new file mode 100644
index 0000000000..62467f37c6
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/italics/index.html
@@ -0,0 +1,68 @@
+---
+title: String.prototype.italics()
+slug: Web/JavaScript/Reference/Global_Objects/String/italics
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - String
+  - italics()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/italics
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code>italics()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i">&lt;i&gt;</a></code> que faz com que uma string fique em itálico.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.italics()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/i">&lt;i&gt;</a></code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>italics()</code> cria uma string dentro de uma tag <code>&lt;i&gt;</code>:<br>
+ <code>"&lt;i&gt;str&lt;/i&gt;"</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_italics">Usando <code>italics()</code></h3>
+
+<p>O exemplo a seguir usa métodos do objeto global String para alterar a formatação de uma string:</p>
+
+<pre class="brush: js notranslate">var worldString = 'Olá, mundo';
+console.log(worldString.blink());  // &lt;blink&gt;Olá, mundo&lt;/blink&gt;
+console.log(worldString.bold());  // &lt;b&gt;Olá, mundo&lt;/b&gt;
+console.log(worldString.italics()); // &lt;i&gt;Olá, mundo&lt;/i&gt;
+console.log(worldString.strike());  // &lt;strike&gt;Olá, mundo&lt;/strike&gt;
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.italics', 'String.prototype.italics')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.italics")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.blink()")}}</li>
+ <li>{{jsxref("String.prototype.bold()")}}</li>
+ <li>{{jsxref("String.prototype.strike()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html b/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html
new file mode 100644
index 0000000000..893b27054c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/lastindexof/index.html
@@ -0,0 +1,162 @@
+---
+title: String.prototype.lastIndexOf()
+slug: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - lastIndexOf
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/lastIndexOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>lastIndexOf()</code> retorna o índice da última ocorrência do valor especificado encontrado na {{jsxref("String")}}. Quando <code>fromIndex</code> é especificado, a pesquisa é realizada de trás para frente. Retorna <code>-1</code> se o valor não for encontrado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.lastIndexOf(<var>searchValue</var>[, <var>fromIndex</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>searchValue</code></dt>
+ <dd>Uma string representando o valor a ser procurado. Se <code>searchValue</code> for uma string vazia, <code>str.length</code> é retornado.</dd>
+ <dt><code>fromIndex</code></dt>
+ <dd>Opcional. O índice no qual a pesquisa será iniciada de trás para frente. O valor padrão é <code>+Infinity</code>. Se <code>fromIndex &gt;= str.length</code>, toda string é pesquisada. Se <code>fromIndex &lt; 0</code>, o comportamento será o mesmo que seria com o índice <code>0</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O índice da última ocorrência referente ao valor especificado em <code>searchValue</code>. É retornado <code>-1</code> se nada for encontrado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Os caracteres em uma string são indexados da esquerda para a direita. O índice do primeiro caractere é <code>0</code>, e o índice do último caractere é <code>str.length - 1</code>.</p>
+
+<pre class="brush: js notranslate">'ricardo'.lastIndexOf('r');     // retorna 4
+'ricardo'.lastIndexOf('a', 3);  // retorna 3
+'ricardo'.lastIndexOf('a', 0);  // retorna -1
+'ricardo'.lastIndexOf('x');     // retorna -1
+'ricardo'.lastIndexOf('r', -5); // retorna 0
+'ricardo'.lastIndexOf('r', 0);  // retorna 0
+'ricardo'.lastIndexOf('');      // retorna 7
+'ricardo'.lastIndexOf('', 2);   // retorna 2
+</pre>
+
+<h3 id="Sensível_a_maiúsculas_e_minúsculas">Sensível a maiúsculas e minúsculas</h3>
+
+<p>O método <code>lastIndexOf()</code> é sensível a letras maiúsculas e minúsculas. Por exemplo, a seguinte expressão retorna <code>-1</code>:</p>
+
+<pre class="brush: js notranslate">'Blue Whale, Killer Whale'.lastIndexOf('blue'); // retorna -1
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_lastIndexOf">Usando <code>lastIndexOf()</code></h3>
+
+<p>O seguinte exemplo usa <code>lastIndexOf()</code> para localizar valores nas string <code>"Brave new world"</code>.</p>
+
+<pre class="brush: js notranslate">var anyString = 'Brave new world';
+
+console.log('O índice do primeiro w a partir do final é ' + anyString.lastIndexOf('w'));
+// retorna 10
+
+console.log('O índice de "new" a partir do final é ' + anyString.lastIndexOf('new'));
+// retorna 6
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.8', 'String.prototype.lastIndexOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.lastindexof', 'String.prototype.lastIndexOf')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.charAt()")}}</li>
+ <li>{{jsxref("String.prototype.indexOf()")}}</li>
+ <li>{{jsxref("String.prototype.split()")}}</li>
+ <li>{{jsxref("Array.prototype.indexOf()")}}</li>
+ <li>{{jsxref("Array.prototype.lastIndexOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/length/index.html b/files/pt-br/web/javascript/reference/global_objects/string/length/index.html
new file mode 100644
index 0000000000..63fd9dac65
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/length/index.html
@@ -0,0 +1,142 @@
+---
+title: String.length
+slug: Web/JavaScript/Reference/Global_Objects/String/length
+tags:
+  - JavaScript
+  - Propriedade
+  - Referencia
+  - String
+  - Tamanho da string
+  - length
+translation_of: Web/JavaScript/Reference/Global_Objects/String/length
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade <code>length</code> de um objeto {{jsxref("String")}} contém o comprimento da string. <code>length</code> é uma propriedade <code>read-only</code> (somente leitura) de instâncias de string.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.length</code></pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Essa propriedade retorna o número de unidades de código presentes na string. {{interwiki("wikipedia", "UTF-16")}}, a codificação utilizada pelo JavaScript, utiliza uma unidade de código de 16-bits para representar os caracteres mais comuns, mas precisa usar duas unidades para caracteres menos usados, então é possível que o valor retornado por <code>length</code> não seja exatamente o número de caracteres na string.</p>
+
+<p>ECMASCript 2016 (ed. 7) estabeleceu um comprimento máximo de <code>2^53 - 1</code> elementos. Anteriormente, nenhum comprimento máximo havia sido especificado. No Firefox, as strings têm um comprimento (<code>length</code>) máximo de <code>2**30 - 2</code> (~ 1 GB). Em versões anteriores ao Firefox 65, o comprimento máximo era <code>2**28 - 1</code> (~ 256 MB).</p>
+
+<p>Para uma string vazia, <code>length</code> é <code>0</code>.</p>
+
+<p>A propriedade estática <code>String.length</code> retorna o valor <code>1</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Uso_básico">Uso básico</h3>
+
+<pre class="brush: js notranslate">var x = 'Mozilla';
+var empty = '';
+
+console.log('Mozilla possui ' + x.length + ' unidades de código de comprimento');
+/* "Mozilla possui 7 unidades de código de comprimento" */
+
+console.log('A string vazia possui um comprimento de ' + empty.length);
+/* "A string vazia possui um comprimento de 0" */
+</pre>
+
+<h3 id="Atribuindo_valor_ao_comprimento">Atribuindo valor ao comprimento</h3>
+
+<pre class="brush: js notranslate">let myString = "campainhas";
+
+// A tentativa de atribuir um valor à propriedade .length
+// de uma string não tem efeito observável.
+
+myString.length = 4;
+console.log(myString);
+// retorna  "campanhias"
+console.log(myString.length);
+// retorna 10
+</pre>
+
+<h2 id="Especificação">Especificação</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">JavaScript <code>String.length</code> and Internationalizing Web Applications</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/link/index.html b/files/pt-br/web/javascript/reference/global_objects/string/link/index.html
new file mode 100644
index 0000000000..547ded08d4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/link/index.html
@@ -0,0 +1,75 @@
+---
+title: String.prototype.link()
+slug: Web/JavaScript/Reference/Global_Objects/String/link
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - link()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/link
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code>link()</code> cria uma string que representa o código para um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a">&lt;a&gt;</a></code> a ser usado como um link de hipertexto para outro URL.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.link(<var>url</var>)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>url</code></dt>
+ <dd>Qualquer string que especifique o atributo <code>href</code> da tag <code>&lt;a&gt;</code>. Deve ser um URL válido (relativo ou absoluto), com qualquer caractere <code>&amp;</code> escapado como <code>&amp;amp</code> e qualquer <code>"</code> caractere escapado como <code>&amp;quot</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/HTML/Element/a">&lt;a&gt;</a></code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Use o método <code>link()</code> para criar um elemento HTML <code>&lt;a&gt;</code>. A string retornada pode então ser adicionada ao documento por meio de <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Document/write" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Document/write">document.write()</a></code> ou <code><a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Element/innerHTML" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/API/Element/innerHTML">element.innerHTML</a></code>.</p>
+
+<p>Os links criados com o método <code>link()</code> tornam-se elementos na array de links do objeto <code>document</code>. Veja <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document/links" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/Document/links">document.links</a></code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_link">Usando <code>link()</code></h3>
+
+<p>O exemplo a seguir exibe a palavra "MDN" como um link que retorna o usuário à Mozilla Developer Network.</p>
+
+<pre class="brush: js notranslate">var hotText = 'MDN';
+var URL = 'https://developer.mozilla.org/';
+
+console.log('Clique para retornar à' + hotText.link(URL));
+// Clique para retornar à &lt;a href="https://developer.mozilla.org/"&gt;MDN&lt;/a&gt;
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.link', 'String.prototype.link')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.link")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.anchor()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html b/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html
new file mode 100644
index 0000000000..9645e8b0f8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/localecompare/index.html
@@ -0,0 +1,163 @@
+---
+title: String.prototype.localeCompare()
+slug: Web/JavaScript/Reference/Global_Objects/String/localeCompare
+tags:
+  - Internacionalização
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - localeCompare()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/localeCompare
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>localeCompare()</code> retorna um número que indica se uma string de referência vem antes ou depois, ou é a mesma que a string fornecida na ordem de classificação.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-localecompare.html")}}</div>
+
+
+
+<p>Os novos argumentos <em><code>locales</code></em> e <em><code>options</code></em> permitem que os aplicativos especifiquem o idioma cuja ordem da ordenação deve ser usada e personalizem o comportamento da função. Em implementações mais antigas, que ignoram os argumentos <em><code>locales</code></em> e <em><code>options</code></em>, a localidade e a ordem de classificação usadas são totalmente dependentes da implementação.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>referenceStr</var>.localeCompare(<var>compareString</var>[, <var>locales</var>[, <var>options</var>]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>compareString</var></code></dt>
+ <dd>A string com a qual a <em><code>referenceStr</code></em> é comparada.</dd>
+ <dt><code><var>locales</var></code> <var>e </var><code><var>options</var></code></dt>
+ <dd>
+ <p>Esses argumentos personalizam o comportamento da função e permitem que os aplicativos especifiquem o idioma cujas convenções de formatação devem ser usadas. Em implementações que ignoram os argumentos <em><code>locales</code></em> e <em><code>options</code></em>, a localidade usada e a forma da string retornada são inteiramente dependentes da implementação.</p>
+
+ <p>Consulte o <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator">construtor </a><code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator">Intl.Collator()</a></code> para obter detalhes sobre esses parâmetros e como usá-los.</p>
+ </dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um número <strong>negativo</strong> se <em><code>referenceStr</code></em> ocorrer antes de <em><code>compareString</code></em>. Um número <strong>positivo</strong> se o <em><code>referenceStr</code></em> ocorrer após <em><code>compareString</code></em>. <code>0</code> se eles forem equivalentes.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Retorna um inteiro indicando se <em><code>referenceStr</code></em> vem antes, depois ou é equivalente a <em><code>compareString</code></em>.</p>
+
+<ul>
+ <li>Negativo quando o <em><code>referenceStr</code></em> ocorre antes de <em><code>compareString</code></em></li>
+ <li>Positivo quando o <em><code>referenceStr</code></em> ocorre após <em><code>compareString</code></em></li>
+ <li>Retorna <code>0</code> se eles forem equivalentes</li>
+</ul>
+
+<div class="blockIndicator warning">
+<p><strong>NÃO confie em valores de retorno exatos de -1 ou 1!</strong></p>
+
+<p>Os resultados de números inteiros negativos e positivos variam entre os navegadores (bem como entre as versões dos navegadores) porque a especificação W3C exige apenas valores negativos e positivos. Alguns navegadores podem retornar <code>-2</code> ou <code>2</code>, ou mesmo algum outro valor negativo ou positivo.</p>
+</div>
+
+<h2 id="Performance">Performance</h2>
+
+<p>Ao comparar um grande número de strings, como na classificação de grandes arrays, é melhor criar um objeto {{jsxref("Global_Objects/Collator", "Intl.Collator")}} e usar a função fornecida por sua propriedade {{jsxref("Collator.prototype.compare", "compare")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_localeCompare">Usando <code>localeCompare()</code></h3>
+
+<pre class="brush: js notranslate">// A letra "a" está antes de "c" produzindo um valor negativo
+'a'.localeCompare('c'); // -2 ou -1 (ou algum outro valor negativo)
+
+// Alfabeticamente, a palavra "verificar" vem depois de "contra", produzindo um valor positivo
+'verificar'.localeCompare('contra'); // 2 ou 1 (ou algum outro valor negativo)
+
+// "a" e "a" são equivalentes, resultando em um valor neutro de zero
+'a'.localeCompare('a'); // 0
+</pre>
+
+<h3 id="Ordenar_um_array">Ordenar um array</h3>
+
+<p><code>localeCompare()</code> permite a ordenação sem distinção entre maiúsculas e minúsculas em um array.</p>
+
+<pre class="brush: js notranslate">let items = ['réservé', 'Premier', 'Cliché', 'communiqué', 'café', 'Adieu'];
+items.sort( (a, b) =&gt; a.localeCompare(b, 'fr', {ignorePunctuation: true}));
+// ['Adieu', 'café', 'Cliché', 'communiqué', 'Premier', 'réservé']
+</pre>
+
+<h3 id="Verifique_o_suporte_do_navegador_para_os_novos_argumentos">Verifique o suporte do navegador para os novos argumentos</h3>
+
+<p>Os argumentos <em><code>locales</code></em> e <em><code>options</code></em> ainda não são suportados em todos os navegadores.</p>
+
+<p>Para verificar se uma implementação os suporta, use o argumento <code>"i"</code> (um requisito de rejeição das tags de linguagem ilegal) e procure uma exceção {{jsxref ("RangeError")}}:</p>
+
+<pre class="brush: js notranslate">function localeCompareSupportsLocales() {
+  try {
+    'foo'.localeCompare('bar', 'i');
+  } catch (e) {
+    return e.name === 'RangeError';
+  }
+  return false;
+}
+</pre>
+
+<h3 id="Usando_locales">Usando <code>locales</code></h3>
+
+<p>Os resultados fornecidos por <code>localeCompare()</code> variam entre os idiomas. Para obter a ordem de classificação do idioma usado na interface do usuário de seu aplicativo, certifique-se de especificar esse idioma (e possivelmente alguns idiomas substitutos) usando o argumento <em><code>locales</code></em>:</p>
+
+<pre class="brush: js notranslate">console.log('ä'.localeCompare('z', 'de')); // um valor negativo: em alemão, ä é classificado antes de z
+console.log('ä'.localeCompare('z', 'sv')); // um valor positivo: em sueco, ä é classificado após z
+</pre>
+
+<h3 id="Usando_options">Usando <code>options</code></h3>
+
+<p>Os resultados fornecidos por <code>localeCompare()</code> podem ser personalizados usando o argumento <em><code>options</code></em>:</p>
+
+<pre class="brush: js notranslate">// em alemão, ä tem a como letra base
+console.log('ä'.localeCompare('a', 'de', { sensitivity: 'base' })); // 0
+
+// em sueco, ä e a são letras de base separadas
+console.log('ä'.localeCompare('a', 'sv', { sensitivity: 'base' })); // um valor positivo
+</pre>
+
+<h3 id="Ordenação_numérica">Ordenação numérica</h3>
+
+<pre class="brush: js notranslate">// por padrão, "2" &gt; "10"
+console.log(<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body">"2".localeCompare("10")</span></span></span>); // 1
+
+// numeric using options:
+console.log(<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body">"2".localeCompare("10", undefined, {numeric: true})</span></span></span>); // -1
+
+// numeric using locales tag:
+console.log(<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body">"2".localeCompare("10", "en-u-kn-true")</span></span></span>); // -1
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.localecompare', 'String.prototype.localeCompare')}}</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sup-String.prototype.localeCompare', 'String.prototype.localeCompare')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.localeCompare")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/match/index.html b/files/pt-br/web/javascript/reference/global_objects/string/match/index.html
new file mode 100644
index 0000000000..1ba4671e90
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/match/index.html
@@ -0,0 +1,232 @@
+---
+title: String.prototype.match()
+slug: Web/JavaScript/Reference/Global_Objects/String/match
+tags:
+  - Expressões Regulares
+  - JavaScript
+  - Métodos
+  - Prototipo
+  - Referencia
+  - String
+  - match()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/match
+---
+<p>{{JSRef("Global_Objects", "String")}}</p>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <code>match()</code> retorna uma correspondência entre uma string com uma <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">expressão regular</a>.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><em>str</em>.match(regexp);</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>regexp</code></dt>
+ <dd>Um objeto de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">expressão regular</a>. Se <em><code>regexp</code></em> não for uma <strong><code>RegExp</code></strong>, o mesmo será convertido para uma nova RegExp usando <code>new <strong>RegExp</strong>(<em>regexp</em>)</code>.<br>
+ <br>
+ Se você não fornecer nenhum parâmetro ao usar o método <code>match()</code>, você obterá um {{jsxref ("Array")}} com uma string vazia: <code>[""]</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<ul>
+ <li>Se o sinalizador <code>g</code> for usado, todos os resultados correspondentes à expressão regular serão retornados, mas a captura de grupos não.</li>
+ <li>se o sinalizador <code>g</code> não for usado, apenas a primeira correspondência completa e seus grupos de captura relacionados serão retornados. Nesse caso, o item devolvido terá propriedades adicionais conforme descrito a seguir.</li>
+</ul>
+
+<dl>
+ <dt><code>array</code></dt>
+ <dd>Um {{jsxref ("Array")}} cujo conteúdo depende da presença ou ausência do sinalizador global (<code>g</code>), ou {{jsxref ("null")}} se nenhuma correspondência for encontrada.</dd>
+</dl>
+
+<h4 id="Propriedades_adicionais">Propriedades adicionais</h4>
+
+<p>Conforme explicado acima, alguns resultados contêm propriedades adicionais conforme descrito abaixo.</p>
+
+<dl>
+ <dt><code>groups</code></dt>
+ <dd>Um objeto de grupos de captura nomeados cujas chaves são os nomes, e valores são os grupos de captura ou {{jsxref ("undefined")}} se nenhum grupo de captura nomeado foi definido. Consulte <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">Grupos e Intervalos</a> para obter mais informações.</dd>
+ <dt><code>index</code></dt>
+ <dd>O índice da pesquisa em que o resultado foi encontrado.</dd>
+ <dt><code>input</code></dt>
+ <dd>Uma cópia da string pesquisada.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Se a expressão regular não incluir o sinalizador <code>g</code>, <code>str.match()</code> retornará o mesmo resultado que {{jsxref ("RegExp.prototype.exec()", "RegExp.exec()")}}.</p>
+
+<h3 id="Notes" name="Notes">Veja também: métodos RegExp</h3>
+
+<ul>
+ <li>Se você precisar saber se uma string corresponde a uma expressão regular, use {{jsxref("RegExp.test()", "RegExp.test()")}}.</li>
+ <li>Se você quiser encontrar apenas uma correspondência, você pode querer usar {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}}.</li>
+ <li>Se você deseja obter grupos de captura e o sinalizador global (<code>g</code>) está definido, você precisa usar {{jsxref("RegExp.prototype.exec()", "RegExp.exec()")}} ou {{jsxref("String. prototype.matchAll() ")}} em vez disso.</li>
+</ul>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Using_match" name="Example:_Using_match">Usando <code>match()</code></h3>
+
+<p>No exemplo a seguir, <code>match()</code> é usado para encontrar "Capítulo", seguido de um ou mais caracteres numéricos, seguido por um ponto decimal e caracteres numéricos 0 ou mais vezes. A expressão inclui a flag <code>i</code> para que diferenças de maiúscula/minúscula sejam ignoradas.</p>
+
+<pre class="brush:js notranslate">var str = "Para maiores informações, veja o Capítulo 3.4.5.1";
+var re = /(capítulo \d+(\.\d)*)/i;
+var found = str.match(re);
+
+console.log(found);
+
+// retorna ["Capítulo 3.4.5.1",
+            "Capítulo 3.4.5.1",
+            ".1",
+            index: 33,
+            input: "Para maiores informações, veja o Capítulo 3.4.5.1"]
+
+// "Capítulo 3.4.5.1" é a primeira correspondência e o primeiro valor
+//  capturado a partir de (capítulo \d+(\.\d)*).
+// ".1" é o útlimo valor de (\.\d).
+// A propriedade "index" (33) é o índice de base zero da correspôndencia inteira.
+// A propriedade "input" é a string original que foi analisada.
+</pre>
+
+<h3 id="Example_Using_global_and_ignore_case_flags_with_match" name="Example:_Using_global_and_ignore_case_flags_with_match">Usando as bandeiras (flags) global e ignore com<br>
+ <code>match()</code></h3>
+
+<p>O exemplo a seguir demonstra o uso das bandeiras (flags) global e ignore com <code>match()</code>. Todas as letras de <code>A</code> a <code>E</code> e <code>a</code> a <code>e</code> são retornadas, com cada letra sendo um elemento no array.</p>
+
+<pre class="brush:js notranslate">var str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+var regexp = /[A-E]/gi;
+var matches_array = str.match(regexp);
+
+console.log(matches_array);
+// <code>['A', 'B', 'C', 'D', 'E', 'a', 'b', 'c', 'd', 'e']</code>
+</pre>
+
+<div class="blockIndicator note">
+<p><strong>Nota:</strong> Veja também {{jsxref("String.prototype.matchAll()")}} e <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions#Pesquisa_avan%C3%A7ada_com_Flags" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions#Pesquisa_avan%C3%A7ada_com_Flags">Pesquisa avançada com sinalizadores</a>.</p>
+</div>
+
+<h3 id="Usando_grupos_de_captura_nomeados">Usando grupos de captura nomeados</h3>
+
+<p>Em navegadores que suportam grupos de captura nomeados, o código a seguir captura "<code>fox</code>" ou "<code>cat</code>" em um grupo denominado "<code>animal</code>":</p>
+
+<pre class="brush: js notranslate">const paragraph = 'The quick brown fox jumps over the lazy dog. It barked.';
+
+const capturingRegex = /(?&lt;animal&gt;fox|cat) jumps over/;
+const found = paragraph.match(capturingRegex);
+console.log(found.groups); // {animal: "fox"}</pre>
+
+<h3 id="Usando_match_sem_parâmetros">Usando <code>match()</code> sem parâmetros</h3>
+
+<pre class="brush: js notranslate">var str = "nada se perde, tudo se transforma";
+
+str.match();  // retorna [""]
+</pre>
+
+<h3 id="Um_objeto_não-RegExp_como_parâmetro">Um objeto não-RegExp como parâmetro</h3>
+
+<p>Quando o parâmetro <em><code>regexp</code></em> é uma string ou um número, ele é convertido implicitamente em um {{jsxref("RegExp")}} usando o <code>new <strong>RegExp</strong>(<em>regexp</em>)</code>.<br>
+ <br>
+ Se for um número positivo com um sinal positivo, <code>RegExp()</code> irá ignorar o sinal positivo.</p>
+
+<pre class="brush: js notranslate"><code>var str1 = "NaN significa 'não é um número'. Infinity contem -Infinity e +Infinity em JavaScript.",
+    str2 = "Meu avô tem 65 anos e minha avô tem 63.",
+    str3 = "O contrato foi declarado null (nulo) e void (sem efeito)";
+str1.match("número");   // "número" é um string. retorna ["número"]
+str1.match(NaN);        // o tipo de NaN é um número. retorna ["NaN"]
+str1.match(Infinity);   // o tipo de Infinity é um número. retorna ["Infinity"]
+str1.match(+Infinity);  // retorna ["Infinity"]
+str1.match(-Infinity);  // retorna ["-Infinity"]
+str2.match(65);         // retorna ["65"]
+str2.match(+65);        // Um número com sinal positivo. retorna ["65"]
+str3.match(null);       // retorna ["null"]</code></pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 3rd Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial.<br>
+    Implementado no JavaScript 1.2</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.10', 'String.prototype.match')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.match', 'String.prototype.match')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("RegExp.prototype.exec()")}}</li>
+ <li>{{jsxref("RegExp.prototype.test()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html b/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html
new file mode 100644
index 0000000000..7399d9e290
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/matchall/index.html
@@ -0,0 +1,146 @@
+---
+title: String.prototype.matchAll()
+slug: Web/JavaScript/Reference/Global_Objects/String/matchAll
+tags:
+  - Expressões Regulares
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - matchAll()
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/matchAll
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>matchAll()</code> retorna um iterador de todos os resultados correspondentes a uma string em relação a uma <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">expressão regular</a>, incluindo <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">grupos de captura</a>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-matchall.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>str</var>.matchAll(<var>regexp</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>regexp</var></code></dt>
+ <dd>
+ <p>Um objeto de expressão regular.</p>
+
+ <p>Se um objeto <em><code>obj</code></em> não-RegExp for passado, ele será convertido implicitamente em um {{jsxref("RegExp")}} usando <code>new RegExp(<em>obj</em>)</code>.</p>
+
+ <p>O objeto <code>RegExp</code> deve ter o sinalizador (flag) <code>/g</code>, caso contrário, um <code>TypeError</code> será retornado.</p>
+ </dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Iteratores_e_geradores" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Iteratores_e_geradores">iterador</a> (que não é um iterável reinicializável).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Regexp.exec_e_matchAll">Regexp.exec() e matchAll()</h3>
+
+<p>Antes da adição do <code>matchAll()</code> ao JavaScript, era possível usar chamadas <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec">regexp.exec</a> (e regexes com a sinalização (flag) <code>/g</code>) em um loop para obter todas as correspondências:</p>
+
+<pre class="brush: js notranslate">const regexp = RegExp('foo[a-z]*','g');
+const str = 'table football, foosball';
+let match;
+
+while ((match = regexp.exec(str)) !== null) {
+  console.log(`Encontrou ${match[0]} início=${match.index} fim=${regexp.lastIndex}.`);
+  // retorna "Encontrou football início=6 fim=14."
+  // retorna "Encontou foosball início=16 fim=24."
+}</pre>
+
+<p>Com o <code>matchAll()</code> disponível, você pode evitar o loop {{jsxref("Statements/while", "while")}} e executar com <code>g</code>.</p>
+
+<p>Em vez disso, usando o <code>matchAll()</code>, você obtém um iterador para usar com o mais conveniente {{jsxref ("Statements/for ... of", "for...of")}}, {{jsxref ("Operators/Spread_syntax" , "array spread")}} ou construções {{jsxref ("Array.from()")}}:</p>
+
+<pre class="brush: js notranslate">const regexp = RegExp('foo[a-z]*','g');
+const str = 'table football, foosball';
+const matches = str.matchAll(regexp);
+
+for (const match of matches) {
+  console.log(`Encontrou ${match[0]} início=${match.index} fim=${match.index + match[0].length}.`);
+}
+// retorna "Encontrou football início=6 fim=14."
+// retorna "Encontrou foosball início=16 fim=24."
+
+// O iterador de correspondências se esgota após a iterção for..of
+// Chame matchAll novamente para criar um novo iterador
+Array.from(str.matchAll(regexp), m =&gt; m[0]);
+// Array [ "football", "foosball" ]</pre>
+
+<p><code>matchAll()</code> retornará uma exceção se o sinalizador (flag) <code>g</code> estiver ausente.</p>
+
+<pre class="brush: js notranslate">const regexp = RegExp('[a-c]','');
+const str = 'abc';
+str.matchAll(regexp);
+// retorna TypeError
+</pre>
+
+<p><code>matchAll()</code> cria internamente um clone da <code>regexp</code> - portanto, ao contrário de {{jsxref("Global_Objects/RegExp/exec", "regexp.exec()")}}, o <code>lastIndex</code> não muda conforme a string é verificada.</p>
+
+<pre class="brush: js notranslate">const regexp = RegExp('[a-c]','g');
+regexp.lastIndex = 1;
+const str = 'abc';
+Array.from(str.matchAll(regexp), m =&gt; `${regexp.lastIndex} ${m[0]}`);
+// Array [ "1 b", "1 c" ]</pre>
+
+<h3 id="Melhor_acesso_para_capturar_grupos_do_que_String.prototype.match">Melhor acesso para capturar grupos (do que String.prototype.match())</h3>
+
+<p>Outra razão convincente para usar <code>matchAll()</code> é o acesso aprimorado para capturar grupos.</p>
+
+<p>Os grupos de captura são ignorados ao usar {{jsxref("Global_Objects/String/match", "match()")}} com o sinalizador global <code>/g</code>:</p>
+
+<pre class="brush: js notranslate">let regexp = /t(e)(st(\d?))/g;
+let str = 'test1test2';
+
+str.match(regexp);
+// Array ['test1', 'test2']</pre>
+
+<p>Usando o <code>matchAll()</code>, você pode acessar os grupos de captura facilmente:</p>
+
+<pre class="brush: js notranslate">let array = [...str.matchAll(regexp)];
+
+array[0];
+// ['test1', 'e', 'st1', '1', index: 0, input: 'test1test2', length: 4]
+array[1];
+// ['test2', 'e', 'st2', '2', index: 5, input: 'test1test2', length: 4]
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.matchall', 'String.prototype.matchAll')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.matchAll")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.match()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">Using regular expressions in JavaScript</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">Capturing groups</a></li>
+ <li>{{jsxref("RegExp")}}</li>
+ <li>{{jsxref("RegExp.prototype.exec()")}}</li>
+ <li>{{jsxref("RegExp.prototype.test()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html b/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html
new file mode 100644
index 0000000000..eb049a0ba5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/normalize/index.html
@@ -0,0 +1,220 @@
+---
+title: String.prototype.normalize()
+slug: Web/JavaScript/Reference/Global_Objects/String/normalize
+tags:
+  - ECMAScript2015
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - Unicode
+  - metodo
+  - normalize()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/normalize
+---
+<div>{{JSRef}}</div>
+
+<p>O método<strong> </strong><code>normalize()</code> retorna a Forma de Normalização Unicode (Unicode Normalization Form) de uma dada string (se o valor não é uma string, ele será convertido para uma primeiramente).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.normalize([<var>form</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>form</code></dt>
+ <dd>Opcional. Um dentre os seguintes valores: <code>"NFC"</code>, <code>"NFD"</code>, <code>"NFKC"</code>, ou <code>"NFKD"</code>, especificando o formato de normalização. Se o valor for omitido ou for {{jsxref("undefined")}}, <code>"NFC"</code> será utilizado.
+ <ul>
+  <li><code>NFC</code> — Formato de Normalização Canônico de Composição. </li>
+  <li><code>NFD</code> — Formato de Normalização Canônico de Decomposição.</li>
+  <li><code>NFKC</code> — Formato de Normalização de Compatibilidade de Composição.</li>
+  <li><code>NFKD</code> — Formato de Normalização de Compatibilidade de Decomposição.</li>
+ </ul>
+ </dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo a Forma de Normalização Unicode da string dada.</p>
+
+<h3 id="Erros_lançados">Erros lançados</h3>
+
+<dl>
+ <dt>{{jsxref("RangeError")}}</dt>
+ <dd>Em erro {{jsxref("RangeError")}} é lançado se <code>form</code> não for um dos valores especificados acima.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O Unicode atribui um valor numérico exclusivo, denominado <em>ponto de código</em>, a cada caractere. Por exemplo, o ponto de código para <em>"A"</em> é fornecido como U+0041. No entanto, às vezes mais de um ponto de código, ou sequência de pontos de código, podem representar o mesmo caractere abstrato - o caractere <code>"ñ"</code>, por exemplo, pode ser representado por:</p>
+
+<ul>
+ <li>Apenas um ponto de código U+00F1.</li>
+ <li>O ponto de código para <code>"n"</code> (U+006E) seguido pelo ponto de código para o til (U+0303).</li>
+</ul>
+
+<pre class="brush: js notranslate">let string1 = '\u00F1';
+let string2 = '\u006E\u0303';
+
+console.log(string1);  //  retorna ñ
+console.log(string2);  //  retorna ñ</pre>
+
+<p>No entanto, como os pontos de código são diferentes, a comparação de strings não os tratará como iguais. E como o número de pontos de código em cada versão é diferente, eles até mesmo possuem comprimentos diferentes.</p>
+
+<pre class="brush: js notranslate">let string1 = '\u00F1';            // ñ
+let string2 = '\u006E\u0303';      // ñ
+
+console.log(string1 === string2); // retorna false
+console.log(string1.length);      // retorna 1
+console.log(string2.length);      // retorna 2</pre>
+
+<p>O método <code>normalize()</code> ajuda a resolver esse problema convertendo uma string em uma forma normalizada comum para todas as sequências de pontos de código que representam os mesmos caracteres. Existem duas principais formas de normalização, uma baseada na <strong>equivalência canônica</strong> e a outra baseada na <strong>compatibilidade</strong>.</p>
+
+<h3 id="Normalização_de_equivalência_canônica">Normalização de equivalência canônica</h3>
+
+<p>Em Unicode, duas sequências de pontos de código têm equivalência canônica se representarem os mesmos caracteres abstratos e tiverem sempre a mesma aparência visual e comportamento (por exemplo, eles devem sempre ser classificados da mesma maneira).</p>
+
+<p>Você pode usar o <code>normalize()</code> usando os argumentos <code>"NFD"</code> ou <code>"NFC"</code> para produzir uma forma de string que será a mesma para todas as strings canonicamente equivalentes. No exemplo abaixo, normalizamos duas representações do caractere <code>"ñ"</code>:</p>
+
+<pre class="brush: js notranslate">let string1 = '\u00F1';           // ñ
+let string2 = '\u006E\u0303';     // ñ
+
+string1 = string1.normalize('NFD');
+string2 = string2.normalize('NFD');
+
+console.log(string1 === string2); // retorna true
+console.log(string1.length);      // retorna 2
+console.log(string2.length);      // retorna 2</pre>
+
+<h4 id="Formas_compostas_e_decompostas"><strong>Formas compostas e decompostas</strong></h4>
+
+<p>Observe que o comprimento da forma normalizada em <code>"NFD"</code> é <code>2</code>. Isso porque <code>"NFD"</code> fornece a versão <strong>decomposta</strong> da forma canônica, na qual pontos de código únicos são divididos em vários combinados. A forma canônica decomposta para <code>"ñ"</code> é <code>"\u006E\u0303"</code>.</p>
+
+<p>Você pode especificar <code>"NFC"</code> para obter a forma canônica <strong>composta</strong>, na qual vários pontos de código são substituídos por pontos de código únicos sempre que possível. A forma canônica composta para <code>"ñ"</code> é <code>"\u00F1"</code>:</p>
+
+<pre class="brush: js notranslate">let string1 = '\u00F1';                           // ñ
+let string2 = '\u006E\u0303';                     // ñ
+
+string1 = string1.normalize('NFC');
+string2 = string2.normalize('NFC');
+
+console.log(string1 === string2);                 // true
+console.log(string1.length);                      // 1
+console.log(string2.length);                      // 1
+console.log(string2.codePointAt(0).toString(16)); // f1</pre>
+
+<h3 id="Normalização_de_compatibilidade">Normalização de compatibilidade</h3>
+
+<p>No Unicode, duas sequências de pontos de código são compatíveis se representarem os mesmos caracteres abstratos e devem ser tratadas da mesma forma em algumas - mas não necessariamente em todas - aplicações.</p>
+
+<p>Todas as sequências canonicamente equivalentes também são compatíveis, mas não o contrário.</p>
+
+<p>Por exemplo:</p>
+
+<ul>
+ <li>o ponto de código U+FB00 representa a <a href="https://wiki.developer.mozilla.org/en-US/docs/Glossary/Ligature" title="https://wiki.developer.mozilla.org/en-US/docs/Glossary/Ligature">ligadura</a> <code>"ff"</code>. É compatível com dois pontos de código U+0066 consecutivos (<code>"ff"</code>).</li>
+ <li>o ponto de código U+24B9 representa o símbolo <code>"Ⓓ"</code>. É compatível com o ponto de código U+0044 (<code>"D"</code>).</li>
+</ul>
+
+<p>Em alguns aspectos (como classificação), eles devem ser tratados como equivalentes - e em alguns (como a aparência visual) não devem, portanto, não são canonicamente equivalentes.</p>
+
+<p>Você pode usar o <code>normalize()</code> usando os argumentos <code>"NFKD"</code> ou <code>"NFKC"</code> para produzir uma forma de string que será a mesma para todas as strings compatíveis:</p>
+
+<pre class="brush: js notranslate">let string1 = '\uFB00';
+let string2 = '\u0066\u0066';
+
+console.log(string1);             // ff
+console.log(string2);             // ff
+console.log(string1 === string2); // false
+console.log(string1.length);      // 1
+console.log(string2.length);      // 2
+
+string1 = string1.normalize('NFKD');
+string2 = string2.normalize('NFKD');
+
+console.log(string1);             // ff &lt;- aparência visual modificada
+console.log(string2);             // ff
+console.log(string1 === string2); // true
+console.log(string1.length);      // 2
+console.log(string2.length);      // 2</pre>
+
+<p>Ao aplicar a normalização de compatibilidade, é importante considerar o que você pretende fazer com as strings, uma vez que a forma normalizada pode não ser apropriada para as aplicações. No exemplo acima, a normalização é apropriada para pesquisa, porque permite que um usuário encontre a string pesquisando por <code>"f"</code>. Mas pode não ser apropriado para exibição, porque a representação visual é diferente.</p>
+
+<p>Como na normalização canônica, você pode solicitar formulários compatíveis decompostos ou compostos passando <code>"NFKD"</code> ou <code>"NFKC"</code>, respectivamente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_normalize"><font face="x-locale-heading-primary, zillaslab, Palatino, Palatino Linotype, x-locale-heading-secondary, serif">Usando </font><code>normalize()</code></h3>
+
+<pre class="brush: js notranslate">// String Inicial
+
+// U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA
+// U+0323: COMBINANDO PONTO ABAIXO
+var str = '\u1E9B\u0323';
+
+
+// Formato de Normalização Canônico de Composição (NFC)
+
+// U+1E9B: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA
+// U+0323: COMBINANDO PONTO ABAIXO
+str.normalize('NFC'); // '\u1E9B\u0323'
+str.normalize();      // igual à linha de cima
+
+
+// Formato de Normalização Canônico de Decomposição (NFD)
+
+// U+017F: CARACTERE LATINO - LETRA S COMPRIDA
+// U+0323: COMBINANDO PONTO ABAIXO
+// U+0307: COMBINANDO PONTO ACIMA
+str.normalize('NFD'); // '\u017F\u0323\u0307'
+
+
+// Formato de Normalização de Compatibilidade de Composição. (NFKC)
+
+// U+1E69: CARACTERE LATINO - LETRA S COMPRIDA COM PONTO ACIMA E ABAIXO
+str.normalize('NFKC'); // '\u1E69'
+
+
+// Formato de Normalização de Compatibilidade de Decomposição (NFKD)
+
+// U+0073: CARACTERE LATINO - LETRA S COMPRIDA
+// U+0323: COMBINANDO PONTO ABAIXO
+// U+0307: COMBINANDO PONTO ACIMA
+str.normalize('NFKD'); // '\u0073\u0323\u0307'
+</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('ES2015', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.normalize', 'String.prototype.normalize')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Nevegadores_compatíveis">Nevegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.normalize")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="http://www.unicode.org/reports/tr15/">Unicode Standard Annex #15, Unicode Normalization Forms</a></li>
+ <li><a href="http://en.wikipedia.org/wiki/Unicode_equivalence">Unicode equivalence</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/padend/index.html b/files/pt-br/web/javascript/reference/global_objects/string/padend/index.html
new file mode 100644
index 0000000000..4c4395451b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/padend/index.html
@@ -0,0 +1,103 @@
+---
+title: String.prototype.padEnd()
+slug: Web/JavaScript/Reference/Global_Objects/String/padEnd
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - padEnd()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/padEnd
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>padEnd()</code> preenche a string original com um determinado caractere, ou conjunto de caraceres, (repetidamente, se necessário) para que a string resultante alcance um determinado comprimento. O preenchimento é aplicado a partir do final (direita) da string original. A string original não é modificada.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-padend.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>str</var>.padEnd(<var>targetLength</var> [, <var>padString</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>targetLength</code></dt>
+ <dd>O comprimento da string resultante após a string original ter sido preenchida. Se o valor for menor do que o próprio comprimento da string original, a string original é retornada sem modificações.</dd>
+ <dt><code>padString</code></dt>
+ <dd>Opcional. O caractere (ou caracteres) que deve completar a string atual. Caso o comprimento desta string seja muito longo, estando acima do comprimento alvo, ela será truncada e sua parte esquerda restante é aplicada. O valor padrão para esse parâmetro é  "<code> </code>" (<code>U+0020</code>).</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma {{jsxref("String")}} cuja composição vem da string original, completada por um ou mais caracteres de preenchimento, respeitando o comprimento alvo.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_padEnd">Usando padEnd</h3>
+
+<pre class="brush: js notranslate">'abc'.padEnd(10);          // "abc       "
+'abc'.padEnd(10, "foo");   // "abcfoofoof"
+'abc'.padEnd(6, "123456"); // "abc123"
+'abc'.padEnd(1);           // "abc"</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Rodando o seguinte código antes de qualquer código irá criar o método <code>String.prototype.padEnd()</code> caso ele não esteja disponível nativamente:</p>
+
+<pre class="brush: js notranslate">// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padEnd
+if (!String.prototype.padEnd) {
+    String.prototype.padEnd = function padEnd(targetLength,padString) {
+        targetLength = targetLength&gt;&gt;0; //floor if number or convert non-number to 0;
+        padString = String((typeof padString !== 'undefined' ? padString : ' '));
+        if (this.length &gt; targetLength) {
+            return String(this);
+        }
+        else {
+            targetLength = targetLength-this.length;
+            if (targetLength &gt; padString.length) {
+                padString += padString.repeat(targetLength/padString.length); //append to original to ensure we are longer than needed
+            }
+            return String(this) + padString.slice(0,targetLength);
+        }
+    };
+}
+</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('ESDraft', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definição inicial no ECMAScript 2017.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES8', '#sec-string.prototype.padend', 'String.prototype.padEnd')}}</td>
+   <td>{{Spec2('ES8')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.padEnd")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.padStart()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html b/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html
new file mode 100644
index 0000000000..3a60ff2489
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/padstart/index.html
@@ -0,0 +1,107 @@
+---
+title: String.prototype.padStart()
+slug: Web/JavaScript/Reference/Global_Objects/String/padStart
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - padStart()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/padStart
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>padStart()</code> preenche a string original com um determinado caractere, ou conjunto de caracteres, (várias vezes, se necessário) até que a string resultante atinja o comprimento fornecido. O preenchimento é aplicado antes do primeiro caractere da string original. A string original não é modificada.</p>
+
+
+
+<div>{{EmbedInteractiveExample("pages/js/string-padstart.html")}}</div>
+
+
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>str</var>.padStart(<var>targetLength</var> [, <var>padString</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>targetLength</code></dt>
+ <dd>O comprimento da string resultante uma vez que a string alvo tenha sido preenchida. Caso seu valor seja menor do que o comprimento da string alvo, é retornado a própria string alvo, sem alterações.</dd>
+ <dt><code>padString</code></dt>
+ <dd>Opcional. O caractere, ou caracteres, que deve preencher a string alvo. Caso o comprimento dessa essa string de preenchimento seja superior ao <code>targetLength</code>, ela será truncada a partir da direita. O valor padrão é <code>" "</code> (<code>U+0020 'SPACE'</code>).</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma {{jsxref("String")}} de comprimento específico com uma string de preenchimento aplicada a partir do seu início.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplos_básicos">Exemplos básicos</h3>
+
+<pre class="brush: js notranslate">'abc'.padStart(10);         // "       abc"
+'abc'.padStart(10, "foo");  // "foofoofabc"
+'abc'.padStart(6,"123465"); // "123abc"
+'abc'.padStart(8, "0");     // "00000abc"
+'abc'.padStart(1);          // "abc"</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Ao executar o seguinte código antes de qualquer outro código é criado o método <code>String.prototype.padStart()</code>, em casos onde ele não está disponível nativamente:</p>
+
+<pre class="brush: js notranslate">// https://github.com/uxitten/polyfill/blob/master/string.polyfill.js
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/padStart
+if (!String.prototype.padStart) {
+    String.prototype.padStart = function padStart(targetLength, padString) {
+        targetLength = targetLength &gt;&gt; 0; //truncate if number, or convert non-number to 0;
+        padString = String(typeof padString !== 'undefined' ? padString : ' ');
+        if (this.length &gt;= targetLength) {
+            return String(this);
+        } else {
+            targetLength = targetLength - this.length;
+            if (targetLength &gt; padString.length) {
+                padString += padString.repeat(targetLength / padString.length); //append to original to ensure we are longer than needed
+            }
+            return padString.slice(0, targetLength) + String(this);
+        }
+    };
+}
+</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('ESDraft', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Implementação inical no ECMAScript 2017.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES8', '#sec-string.prototype.padstart', 'String.prototype.padStart')}}</td>
+   <td>{{Spec2('ES8')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.padStart")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.padEnd()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html
new file mode 100644
index 0000000000..14594dfaf6
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/prototype/index.html
@@ -0,0 +1,176 @@
+---
+title: String.prototype
+slug: Web/JavaScript/Reference/Global_Objects/String/prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/String
+---
+<div>{{JSRef}}</div>
+
+<p>A <strong><code>String.prototype</code></strong> representa o prototipo de objeto  {{jsxref("String")}}.</p>
+
+<div>{{js_property_attributes(0, 0, 0)}}</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Todas as instâncias {{jsxref("String")}} herdam de <code>String.prototype</code>. Alterações na <code>String</code> são propagadas para todas as instâncias {{jsxref("String")}}.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>String.prototype.constructor</code></dt>
+ <dd>Especifica a função que cria o protótipo de um objeto.</dd>
+ <dt>{{jsxref("String.prototype.length")}}</dt>
+ <dd>Reflete o comprimento da string.</dd>
+ <dt><code><em>N</em></code></dt>
+ <dd>Usado para acessar o caractere na posição <em>N</em> onde <em>N</em> é um número inteiro entre 0 e um menor que o valor da <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function/length">length</a></code>. Estas propriedades são apenas de leitura.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<h3 id="Métodos_não_relacionados_ao_HTML">Métodos não relacionados ao HTML</h3>
+
+<dl>
+ <dt>{{jsxref("String.prototype.charAt()")}}</dt>
+ <dd>Retorna o caractere (exatamente uma unidade de código UTF-16) no índice especificado.</dd>
+ <dt>{{jsxref("String.prototype.charCodeAt()")}}</dt>
+ <dd>Retorna um número que é o valor da unidade de código UTF-16 em dado índice.</dd>
+ <dt>{{jsxref("String.prototype.codePointAt()")}}</dt>
+ <dd>Retorna um número inteiro não negativo Number que é o valor de posição de código da posição de código inicial em dado índice.</dd>
+ <dt>{{jsxref("String.prototype.concat()")}}</dt>
+ <dd>Combina o texto de duas strings e retorna uma nova string.</dd>
+ <dt>{{jsxref("String.prototype.includes()")}}</dt>
+ <dd> Determina se uma string deve ser encontrada dentro de outra string.</dd>
+ <dt>{{jsxref("String.prototype.endsWith()")}}</dt>
+ <dd>Determina se uma string termina com os caracteres de outra string.</dd>
+ <dt>{{jsxref("String.prototype.indexOf()")}}</dt>
+ <dd>Retorna o índice dentro do objeto String chamado da primeira ocorrência do valor especificado, ou -1 se não encontrado.</dd>
+ <dt>{{jsxref("String.prototype.lastIndexOf()")}}</dt>
+ <dd>Retorna o índice dentro do objeto String chamado da última ocorrência do valor especificado, ou -1 se não encontrado.</dd>
+ <dt>{{jsxref("String.prototype.localeCompare()")}}</dt>
+ <dd>Retorna um número indicando se uma string de referência vem antes ou depois ou é o mesmo que uma string dada em ordem de classificação.</dd>
+ <dt>{{jsxref("String.prototype.match()")}}</dt>
+ <dd>Usado para combinar uma expressão regular com uma string.</dd>
+ <dt>{{jsxref("String.prototype.normalize()")}}</dt>
+ <dd>Retorna o Formulário de Normalização Unicode do valor string chamado.</dd>
+ <dt>{{jsxref("String.prototype.padEnd()")}}</dt>
+ <dd>Empacota a string atual desde o final com uma string dada para criar uma nova string de um dado comprimento.</dd>
+ <dt>{{jsxref("String.prototype.padStart()")}}</dt>
+ <dd>Empacota a string atual desde o início com uma string dada para criar uma nova string de um dado comprimento.</dd>
+ <dt><s class="obsoleteElement">{{jsxref("String.prototype.quote()")}} {{obsolete_inline}}</s></dt>
+ <dd><s class="obsoleteElement">Envolve a cadeia entre aspas duplas ("" ").</s></dd>
+ <dt>{{jsxref("String.prototype.repeat()")}}</dt>
+ <dd>Retorna uma string consistindo elementos do objeto repetido pelas vezes definidas.</dd>
+ <dt>{{jsxref("String.prototype.replace()")}}</dt>
+ <dd>Usado para encontrar uma combinação entre uma expressão regular e uma string, e para substituir uma substring combinada com uma nova substring.</dd>
+ <dt>{{jsxref("String.prototype.search()")}}</dt>
+ <dd>Executa a procura por uma combinação entre uma expressão regular e uma string especificada.</dd>
+ <dt>{{jsxref("String.prototype.slice()")}}</dt>
+ <dd>Extrai uma seção de uma string e retorna uma nova string.</dd>
+ <dt>{{jsxref("String.prototype.split()")}}</dt>
+ <dd>Separa um objeto <a href="pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String" title="The String global object is a constructor for strings, or a sequence of characters."><code>String</code></a> em um array de strings separando a string em substrings.</dd>
+ <dt>{{jsxref("String.prototype.startsWith()")}}</dt>
+ <dd>Determina se uma string começa com os caracteres de outra string.</dd>
+ <dt>{{jsxref("String.prototype.substr()")}}</dt>
+ <dd>Retorna os caracteres em uma string começando no local especificado através do número especificado de caracteres.</dd>
+ <dt>{{jsxref("String.prototype.substring()")}}</dt>
+ <dd>Retorna os caracteres em uma string entre dois índices na string.</dd>
+ <dt>{{jsxref("String.prototype.toLocaleLowerCase()")}}</dt>
+ <dd>Os caracteres dentro de uma string são convertidos para letras minúsculas enquanto respeita a localidade atual. Para a maioria das línguas, irá retornar o mesmo que <a href="pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase" title="The toLowerCase() method returns the calling string value converted to lower case."><code>toLowerCase()</code></a>.</dd>
+ <dt>{{jsxref("String.prototype.toLocaleUpperCase()")}}</dt>
+ <dd>Os caracteres dentro de uma string são convertidas para letra maiúscula enquanto respeita a localidade atual. Para a maioria das línguas, irá retornar o mesmo que <a href="pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase" title="The toUpperCase() method returns the calling string value converted to upper case."><code>toUpperCase()</code></a>.</dd>
+ <dt>{{jsxref("String.prototype.toLowerCase()")}}</dt>
+ <dd>Retorna o valor da string de chamada convertido em minúsculas.</dd>
+ <dt>{{jsxref("String.prototype.toSource()")}} {{non-standard_inline}}</dt>
+ <dd>Retorna um objeto literal representando o objeto especificado; Você pode usar esse valor para criar um novo objeto. Substitui o metodo:{{jsxref("Object.prototype.toSource()")}}</dd>
+ <dt>{{jsxref("String.prototype.toString()")}}</dt>
+ <dd>Retorna uma string que representa o objeto especificado. Substitui o metodo:{{jsxref("Object.prototype.toString()")}}</dd>
+ <dt>{{jsxref("String.prototype.toUpperCase()")}}</dt>
+ <dd>Retorna o valor da string de chamada convertido em maiúscula.</dd>
+ <dt>{{jsxref("String.prototype.trim()")}}</dt>
+ <dd>Retira o espaço em branco desde o início e o fim da string. Parte do padrão ECMAScript 5.</dd>
+ <dt>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</dt>
+ <dd>Retira o espaço em branco do lado esquerdo da string.</dd>
+ <dt>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</dt>
+ <dd>Retira o espaço em branco do lado esquerdo da string.</dd>
+ <dt>{{jsxref("String.prototype.valueOf()")}}</dt>
+ <dd>Retorna o valor primitivo do objeto especificado. Substitui o metodo: {{jsxref("Object.prototype.valueOf()")}} </dd>
+ <dt>{{jsxref("String.prototype.@@iterator()", "String.prototype[@@iterator]()")}}</dt>
+ <dd>Retorna um novo objeto  <code>Iterator </code>que repete sobre os pontos de código de um valor String, retornando cada ponto de código como um valor String.</dd>
+</dl>
+
+<h3 id="Métodos_de_envoltório_HTML">Métodos de envoltório HTML</h3>
+
+<p>Esses métodos são de uso limitado, pois fornecem apenas um subconjunto das tags e atributos HTML disponíveis.</p>
+
+<dl>
+ <dt>{{jsxref("String.prototype.anchor()")}}</dt>
+ <dd>{{htmlattrxref("name", "a", "&lt;a name=\"name\"&gt;")}} (alvo hipertexto)</dd>
+ <dt>{{jsxref("String.prototype.big()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("big")}}</dd>
+ <dt>{{jsxref("String.prototype.blink()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("blink")}}</dd>
+ <dt>{{jsxref("String.prototype.bold()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("b")}}</dd>
+ <dt>{{jsxref("String.prototype.fixed()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("tt")}}</dd>
+ <dt>{{jsxref("String.prototype.fontcolor()")}} {{deprecated_inline}}</dt>
+ <dd>{{htmlattrxref("color", "font", "&lt;font color=\"color\"&gt;")}}</dd>
+ <dt>{{jsxref("String.prototype.fontsize()")}} {{deprecated_inline}}</dt>
+ <dd>{{htmlattrxref("size", "font", "&lt;font size=\"size\"&gt;")}}</dd>
+ <dt>{{jsxref("String.prototype.italics()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("i")}}</dd>
+ <dt>{{jsxref("String.prototype.link()")}}</dt>
+ <dd>{{htmlattrxref("href", "a", "&lt;a href=\"url\"&gt;")}} (link para URL)</dd>
+ <dt>{{jsxref("String.prototype.small()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("small")}}</dd>
+ <dt>{{jsxref("String.prototype.strike()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("strike")}}</dd>
+ <dt>{{jsxref("String.prototype.sub()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("sub")}}</dd>
+ <dt>{{jsxref("String.prototype.sup()")}} {{deprecated_inline}}</dt>
+ <dd>{{HTMLElement("sup")}}</dd>
+</dl>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificacoes</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentarios</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.3.1', 'String.prototype')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype', 'String.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype', 'String.prototype')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_browsers">Compatibilidade entre browsers</h2>
+
+<p class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, verifique <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um pedido de participação.</p>
+
+<p>{{Compat("javascript.builtins.String.prototype")}}</p>
+
+<h2 id="Veja_também">Veja também </h2>
+
+<ul>
+ <li>{{jsxref("String")}}</li>
+ <li>{{jsxref("Function.prototype")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/raw/index.html b/files/pt-br/web/javascript/reference/global_objects/string/raw/index.html
new file mode 100644
index 0000000000..86cfe1b25b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/raw/index.html
@@ -0,0 +1,120 @@
+---
+title: String.raw()
+slug: Web/JavaScript/Reference/Global_Objects/String/raw
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Referencia
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/raw
+---
+<div>{{JSRef}}</div>
+
+<p>O método estático <code>String.raw()</code> é uma função tag de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings">modelos literais</a>, similar ao prefixo <code>r</code> no Python ou o prefixo <code>@</code> no C# para string literais (Mas não é <em>idêntico</em>, existe uma diferença, veja explicações nessa <a href="https://bugs.chromium.org/p/v8/issues/detail?id=5016">discussão</a>). Ele é usado para pegar as strings no formato "cru" de modelos literais, isto é, substituições (ex: <font face="consolas, Liberation Mono, courier, monospace"><span style="">${foo}</span></font>) são processados, mas "escapes" (ex:. <code>\n</code>) não são.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/string-raw.html")}}</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>String.raw(<var>callSite</var>, <var>...sub</var>)
+
+String.raw`templateString`
+</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>callSite</code></dt>
+ <dd> Modelo bem-formatado de objeto de local de chamada, como <code>{ raw: ['foo', 'bar', 'baz'] }</code>.</dd>
+ <dt><code>...substitutions</code></dt>
+ <dd>Contém os valores das substituições.</dd>
+ <dt><code>templateString</code></dt>
+ <dd>Um <a href="/en-US/docs/Web/JavaScript/Reference/template_strings">modelo string</a>, opcionalmente com substituições (<code>${...}</code>).</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>A forma crua de uma string de um modelo string dado.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<dl>
+ <dt>{{jsxref("TypeError")}}</dt>
+ <dd>Um {{jsxref("TypeError")}} é jogado se o primeiro argumento não é um Objeto bem formado.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Na maioria dos casos, <code>String.raw()</code> é usado com modelos de strings. A primeira sintaxe mencionada acima raramente é usada, porque o mecanismo JavaScript a chamará com os argumentos apropriados para você, assim como com outras <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/template_strings">funções de tag</a>.</p>
+
+<p><code>String.raw()</code> é a única função de tag embutida de strings de template; ele funciona exatamente como a função de modelo padrão e executa a concatenação. Você pode até reimplementá-lo com o código JavaScript normal.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_String.raw">Usando <code>String.raw()</code></h3>
+
+<pre class="brush: js notranslate">String.raw`Hi\n${2+3}!`;
+// 'Hi\n5!', o caractere após 'Hi'
+// não é um caractere de quebra de linha,
+// '\' e 'n' são dois caracteres.
+
+String.raw`Hi\u000A!`;
+// 'Hi\u000A!', o mesmo aqui, agora nós teremos os caracteres
+//  \, u, 0, 0, 0, A, 6.
+// Todos as formas de quebra de linha serão ineficazes
+// e as contra barras estarão inclusas no valor retornado.
+// Você pode confirmar isso verificando a propriedade .length
+// da string.
+
+let name = 'Bob';
+String.raw`Hi\n${name}!`;
+// 'Hi\nBob!', substituições são processadas.
+
+// Normalmente você não chamaria String.raw() como uma função,
+// mas para simular `t${0}e${1}s${2}t` você pode fazer:
+String.raw({ raw: 'test' }, 0, 1, 2); // 't0e1s2t'
+// Note que 'test', uma string, é um objeto array-like
+// O código abaixo é equivalente a:
+// `foo${2 + 3}bar${'Java' + 'Script'}baz`
+String.raw({
+  raw: ['foo', 'bar', 'baz']
+}, 2 + 3, 'Java' + 'Script'); // 'foo5barJavaScriptbaz'
+
+</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('ES2015', '#sec-string.raw', 'String.raw')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.raw', 'String.raw')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.raw")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/template_strings">Modelos de strings</a></li>
+ <li>{{jsxref("String")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">Gramática lexical</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html b/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html
new file mode 100644
index 0000000000..94cdca3831
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/repeat/index.html
@@ -0,0 +1,294 @@
+---
+title: String.prototype.repeat()
+slug: Web/JavaScript/Reference/Global_Objects/String/repeat
+tags:
+  - JavaScript
+  - Prototype
+  - Referencia
+  - Repetir
+  - String
+  - metodo
+  - repeat()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/repeat
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>repeat()</code></strong> constrói e retorna uma nova string com um determinado número de cópias concatenadas da string original.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.repeat(<var>count</var>);</code>
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>count</code></dt>
+ <dd>Um número inteiro entre 0 e  {{jsxref("Global_Objects/Number/POSITIVE_INFINITY", "+Infinity")}}, indicando o número de vezes que a string deve ser repetida.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova string contendo o número especificado de cópias da string original.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<ul>
+ <li>{{jsxref("Errors/Negative_repetition_count", "RangeError")}}: o número de repetições não pode ser negativo.</li>
+ <li>{{jsxref("Errors/Resulting_string_too_large", "RangeError")}}: o número de repetições deve ser menor que infinito e não deve ultrapassar o tamanho máximo da string.</li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js notranslate">'abc'.repeat(-1);   // RangeError
+'abc'.repeat(0);    // ''
+'abc'.repeat(1);    // 'abc'
+'abc'.repeat(2);    // 'abcabc'
+'abc'.repeat(3.5);  // 'abcabcabc' (o número será convertido para inteiro)
+'abc'.repeat(1/0);  // RangeError
+
+({ toString: () =&gt; 'abc', repeat: String.prototype.repeat }).repeat(2);
+// 'abcabc' (repeat() é um método genérico)
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>O método <code>repeat()</code> foi adicionado à especificação ECMAScript 2015 e pode ainda não estar disponível em todas as implementações do JavaScript. No entanto, você pode usar o seguinte polyfill para implementar o <code>String.prototype.repeat()</code>:</p>
+
+<pre class="brush: js notranslate">if (!String.prototype.repeat) {
+  String.prototype.repeat = function(count) {
+    'use strict';
+    if (this == null) {
+      throw new TypeError('não é possível converter ' + this + ' para um objeto');
+    }
+    var str = '' + this;
+    count = +count;
+    if (count != count) {
+      count = 0;
+    }
+    if (count &lt; 0) {
+      throw new RangeError('o núm. de repetições não pode ser negativo');
+    }
+    if (count == Infinity) {
+      throw new RangeError('o núm. de repetições deve ser menor que infinito');
+    }
+    count = Math.floor(count);
+    if (str.length == 0 || count == 0) {
+      return '';
+    }
+
+    // Ao Garantir que count seja um inteiro de 31 bits nos dá uma grande otimização
+    // na parte principal. Porém, navegadores atuais (de agosto de 2014 pra cá)
+    // não conseguem mais manipular strings de 1 &lt;&lt; 28 chars ou maiores, então:
+    if (str.length * count &gt;= 1 &lt;&lt; 28) {
+      throw new RangeError('o núm. de repetições não deve estourar o tamanho máx. de uma string');
+    }
+    var rpt = '';
+    for (var i = 0; i &lt; count; i++) {
+      rpt += str;
+    }
+    return rpt;
+  }
+}
+</pre>
+
+<h4 id="Polyfill_ES5">Polyfill ES5</h4>
+
+<pre class="syntaxbox notranslate">//#es5
+'use strict';
+(function(win){
+ var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o &amp;&amp; typeof(o)==='function' &amp;&amp; typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x &amp;&amp; x.constructor===o &amp;&amp; x!==p?'symbol':typeof x}};return f})(win),
+ exist=function(o,p,t){return p in o &amp;&amp; typeOf(o[p])===t};
+ (function(w){
+    var o=w.String.prototype;
+    if(!exist(o,'repeat','function')){o.repeat=(function(A,E){return function(n){var i=n&gt;&gt;0,s=this,l=s.length,j;if(i===0||l&lt;1){s=''}else{j=268435456;if(i&lt;0||i&gt;=j||i*l&gt;j){throw new RE('Invalidcountvalue')}else if(i&gt;0){s=A(++i).join(s)}};return s}})(w.Array,w.RangeError)};
+ })(win);
+})(window);
+
+// teste:
+console.clear();
+console.log(
+'abc'.repeat(false),//''
+'abc'.repeat({}),//''
+'abc'.repeat([]),//''
+'abc'.repeat(['']),//''
+'abc'.repeat([0]),//''
+'abc'.repeat([0,1]),//''
+'abc'.repeat([1,1]),//''
+'abc'.repeat(0),//''
+'abc'.repeat(.6),//''
+'abc'.repeat(true),//'abc'
+'abc'.repeat(1),//'abc'
+'abc'.repeat(2),//'abcabc'
+'abc'.repeat([2]),//'abcabc'
+'abc'.repeat(3.5),//'abcabcabc'
+''.repeat(2)//''
+);
+console.log(
+'abc'.repeat(-Infinity),//RangeError: Invalid count value
+'abc'.repeat(Infinity),//RangeError: Invalid count value
+'abc'.repeat(1/0),//RangeError: Invalid count value
+'abc'.repeat(-1)//RangeError: Invalid count value
+);
+
+/*
+es5 src:
+'use strict';
+(function(win){
+
+ var typeOf=(function(w){var f=function f(x){return typeof(x)},o=w.Symbol,p;if(o &amp;&amp; typeof(o)==='function' &amp;&amp; typeof(o.iterator)==='symbol'){p=o.prototype;f=function(x){return x &amp;&amp; x.constructor===o &amp;&amp; x!==p?'symbol':typeof x}};return f})(win),
+ exist=function(o,p,t){return p in o &amp;&amp; typeOf(o[p])===t};
+
+ (function(w){
+    var o=w.String.prototype;
+    if(!exist(o,'repeat','function')){
+        o.repeat=(function(A,E){
+            return function(n){
+                var i=n&gt;&gt;0,s=this,l=s.length,j;
+                if(i===0||l&lt;1){s=''}else{
+                    j=268435456;
+                    if(i&lt;0||i&gt;=j||i*l&gt;j){throw new RE('Invalidcountvalue')}else if(i&gt;0){s=A(++i).join(s)}
+                };
+                return s
+            };
+        })(w.Array,w.RangeError);
+    };
+    //..
+ })(win);
+
+})(window);
+*/
+</pre>
+
+<h4 id="Polyfill_ES6">Polyfill ES6</h4>
+
+<pre class="syntaxbox notranslate">//#es6
+
+(w=&gt;{
+
+    const typeOf=(o=&gt;{let f=x=&gt;typeof x;if(o &amp;&amp; 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=&gt;x &amp;&amp; x.constructor===o &amp;&amp; x!==p?s:typeof x}};return f})(w.Symbol),
+
+    exist=(o,p,t)=&gt;p in o &amp;&amp; typeOf(o[p])===t;
+
+    (o=&gt;{
+
+        if(!exist(o,'repeat','function')){const A=w.Array,E=w.RangeError;o.repeat=function(n){var i=n&gt;&gt;0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i&lt;0||i&gt;=(t=268435456)||i*l&gt;t){throw new E('Invalid count value')}else if(i&gt;0){s=A(++i).join(t)}}};return s}};
+
+    })(w.String.prototype);
+
+})(window);
+
+/*
+
+es6 src:
+
+(w=&gt;{
+
+    const typeOf=(o=&gt;{let f=x=&gt;typeof x;if(o &amp;&amp; 'function'===typeof o){const s='symbol';if(s===typeof o.iterator){const p=o.prototype;f=x=&gt;x &amp;&amp; x.constructor===o &amp;&amp; x!==p?s:typeof x}};return f})(w.Symbol),
+
+    exist=(o,p,t)=&gt;p in o &amp;&amp; typeOf(o[p])===t;
+
+
+    (o=&gt;{
+
+        if(!exist(o,'repeat','function')){
+
+            const A=w.Array;
+
+            o.repeat=function(n){var i=n&gt;&gt;0,s='';if(i!==0){let t=this;const l=t.length;if(l!==0){if(i&lt;0||i&gt;=(t=268435456)||i*l&gt;t){throw new RangeError('Invalid count value')}else if(i&gt;0){s=A(++i).join(t)}}};return s};
+
+        };
+
+        //..
+
+    })(w.String.prototype);
+
+
+})(window);
+
+*/
+
+
+//test:
+
+console.clear();
+
+console.log(
+
+'abc'.repeat(false),//''
+
+'abc'.repeat({}),//''
+
+'abc'.repeat([]),//''
+
+'abc'.repeat(['']),//''
+
+'abc'.repeat([0]),//''
+
+'abc'.repeat([0,1]),//''
+
+'abc'.repeat([1,1]),//''
+
+'abc'.repeat(0),//''
+
+'abc'.repeat(.6),//''
+
+'abc'.repeat(true),//'abc'
+
+'abc'.repeat(1),//'abc'
+
+'abc'.repeat(2),//'abcabc'
+
+'abc'.repeat([2]),//'abcabc'
+
+'abc'.repeat(3.5),//'abcabcabc'
+
+''.repeat(2)//''
+
+);
+
+console.log(
+
+'abc'.repeat(-Infinity),//RangeError: Invalid count value
+
+'abc'.repeat(Infinity),//RangeError: Invalid count value
+
+'abc'.repeat(1/0),//RangeError: Invalid count value
+
+'abc'.repeat(-1)//RangeError: Invalid count value
+
+);</pre>
+
+<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>{{SpecName('ES2015', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.repeat', 'String.prototype.repeat')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">A tabela de compatibilidade nesta página foi gerada a partir de dados estruturados. Se você quiser contribuir para esses dados, vá para <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.repeat")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.concat()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/replace/index.html b/files/pt-br/web/javascript/reference/global_objects/string/replace/index.html
new file mode 100644
index 0000000000..8d1863363b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/replace/index.html
@@ -0,0 +1,352 @@
+---
+title: String.prototype.replace()
+slug: Web/JavaScript/Reference/Global_Objects/String/replace
+tags:
+  - Expressões Regulares
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - replace()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/replace
+---
+<div>{{JSRef("Global_Objects", "String")}}</div>
+
+<h2 id="Resumo">Resumo</h2>
+
+<p>O método <code>replace()</code> retorna uma nova string com algumas ou todas as correspondências de um padrão substituídas por um determinado caractere (ou caracteres). O padrão pode ser uma string ou uma {{jsxref("RegExp")}}, e a substituição pode ser uma string ou uma função a ser chamada para cada correspondência. Se o padrão for uma string, apenas a primeira ocorrência será substituída.</p>
+
+<p>A string original não é modificada.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.replace(<var>regexp</var>|<var>substr</var>, <var>newSubStr</var>|<var>function</var>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>regexp </code></dt>
+ <dd><span class="tlid-translation translation"><span title="">Um objeto {{jsxref ("RegExp")}} ou literal. A correspondência ou correspondências são substituídas por <em><code>newSubStr</code></em> ou o valor retornado pela <code>function</code> especificada.</span></span></dd>
+ <dt><code>substr</code></dt>
+ <dd><span class="tlid-translation translation"><span title="">Uma {{jsxref ("String")}} que será substituída por <code>newSubStr</code>.</span> <span title="">Ele é tratado como uma string textual e não é interpretado como uma expressão regular.</span> <span title="">Apenas a primeira ocorrência será substituída.</span></span></dd>
+ <dt><code>newSubStr</code></dt>
+ <dd>A {{jsxref("Global_Objects/String", "String")}} que substitui a <code>substr</code> recebida do parâmetro #1. Uma série de padrões de substituições especiais são suportados. Veja a seção "<a href="#" id="Specifying_a_string_as_a_parameter">Especificando uma string como parâmetro</a>" abaixo.</dd>
+ <dt><code>function</code></dt>
+ <dd>A função (function) chamada cria uma nova substring (para ser colocada no lugar da substring recebida pelo parametro #1). Os argumentos fornececidos para essa função estão descritos na seção "<a href="#" id="Specifying_a_string_as_a_parameter">Especificando uma função como parâmetro</a>" mais abaixo.</dd>
+ <dt><code>flags</code> {{non-standard_inline}}</dt>
+ <dd>
+ <p>Uma string especificando uma combinação de <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">flags de expressão regular</a>. O uso do parâmetro <code>flags</code> no método <code>String.prototype.replace()</code> é não-padrão. Ao invés de usar este parâmetro, use um objeto {{jsxref("Global_Objects/RegExp", "RegExp")}} com as flags correspondentes. O valor deste parâmetro deve ser uma string consistindo em um ou mais dos seguintes caracteres para afetar a operação, tais como descrito:</p>
+
+ <dl>
+  <dt><code>g</code></dt>
+  <dd>Combinação global.</dd>
+  <dt><code>i</code></dt>
+  <dd>Ignora diferenças entre maiúsculas e minúsculas.</dd>
+  <dt><code>m</code></dt>
+  <dd>Combinação em várias linhas.</dd>
+  <dt><code>y</code> {{experimental_inline}}</dt>
+  <dd>Sticky</dd>
+ </dl>
+
+ <div class="blockIndicator note">
+ <p><strong>Nota: </strong>O argumento <code>flags</code> não funciona no v8 Core (Chrome e NodeJs).</p>
+ </div>
+ </dd>
+</dl>
+
+<h3 id="Returns" name="Returns">Valor retornado</h3>
+
+<p>Uma nova string com alguma ou todas as combinações do padrão substituído(s) pelo valor de substituição.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Este método não muda o objeto {{jsxref("Global_Objects/String", "String")}}. Ele simplesmente retorna uma nova string.</p>
+
+<p>Para realizar uma pesquisa global e substituir, inclua a flag <code>g</code> na expressão regular ou se o primeiro parâmetro for uma string, inclua <code>g</code> no parâmetro flags.</p>
+
+<h3 id="Specifying_a_string_as_a_parameter" name="Specifying_a_string_as_a_parameter">Especificando uma string como parâmetro</h3>
+
+<p>A string substituidora pode incluir o seguinte padrão de substituição especial:</p>
+
+<table class="fullwidth-table" style="height: 140px; width: 575px;">
+ <tbody>
+  <tr>
+   <td class="header"><strong>Padrão       </strong></td>
+   <td class="header"><strong>Insere</strong></td>
+  </tr>
+  <tr>
+   <td><code>$$</code></td>
+   <td>Insere um "$".</td>
+  </tr>
+  <tr>
+   <td><code>$&amp;</code></td>
+   <td>Insere a string casada.</td>
+  </tr>
+  <tr>
+   <td><code>$`</code></td>
+   <td>Insere a porção da string que precede a substring combinada.</td>
+  </tr>
+  <tr>
+   <td><code>$'</code></td>
+   <td>Insere a porção da string que segue a substring combinada.</td>
+  </tr>
+  <tr>
+   <td><code>$<em>n</em></code> ou <code>$<em>nn</em></code></td>
+   <td>Onde <code><em>n</em></code> ou <code><em>nn</em></code> são dígitos decimais, insere a <em>n</em>-ésima substring entre parêntesis casada, dado o primeiro argumento foi um objeto {{jsxref("Global_Objects/RegExp", "RegExp")}}.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="Specifying_a_function_as_a_parameter" name="Specifying_a_function_as_a_parameter">Especificando uma função como parâmetro</h3>
+
+<p>Você pode especificar uma função no segundo parâmetro. Neste caso, a função será chamada depois que a correspôndecia for encontrada. O resultado da função (valor retornado) será usado como a string substituta. (Atenção: os padrões de substituição citados acima não se aplicam neste caso). Note que a função será chamada múltiplas vezes para combinação que deve ser substituída se a expressão regular no primeiro parâmetro tiver a regra global.</p>
+
+<p>Os parâmetros da função são:</p>
+
+<table class="fullwidth-table" style="height: 375px; width: 490px;">
+ <tbody>
+  <tr>
+   <td class="header"><strong>Possíveis nomes            </strong></td>
+   <td class="header"><strong>Valor fornecido</strong></td>
+  </tr>
+  <tr>
+   <td><code>match</code></td>
+   <td>A substring encontrada. Corresponde ao <code>$&amp;</code> acima.</td>
+  </tr>
+  <tr>
+   <td><code>p1, p2, ...</code></td>
+   <td>O enésimo parâmetro entre parênteses da RegEx no primeiro parâmetro na função <code>replace()</code> {{jsxref("Global_Objects/RegExp", "RegExp")}}. (Corresponde a <code>$1</code>, <code>$2</code>, etc. acima.) Por exemplo, se <code>/(\a+)(\b+)/</code>, for o primeiro parâmetro, <code>p1</code> é a combinação para <code>\a+</code>, e <code>p2</code> para <code>\b+</code>.</td>
+  </tr>
+  <tr>
+   <td><code>offset</code></td>
+   <td>O offset da string encontrada em relação ao resto da string. Por exemplo, se a string for 'abcd' e a string a ser encontrada for 'bc', então este parâmetro terá o valor 1.</td>
+  </tr>
+  <tr>
+   <td>
+    <p><code>string</code></p>
+   </td>
+   <td>
+    <p>A string completa que está sendo examinada.</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<p>(O número exato de argumentos dependerá se o primeiro parâmetro for uma {{jsxref("Global_Objects/RegExp", "RegExp")}} e de quantas combinações entre parênteses houver).</p>
+
+<p>O exemplo a seguir irá substituir o valor de <code>newString</code> para <code>'abc - 12345 - #$*%'</code>:</p>
+
+<pre class="brush: js notranslate">function replacer(match, p1, p2, p3, offset, string) {
+  // p1 não possui digitos,
+  // p2 possui dígitos, e p3 não possui alfanuméricos
+  return [p1, p2, p3].join(' - ');
+}
+var newString = 'abc12345#$*%'.replace(/([^\d]*)(\d*)([^\w]*)/, replacer);
+
+// retorna <span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string">"abc - 12345 - #$*%"</span></span></span></span>
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Definindo_uma_expressão_regular_com_replace">Definindo uma expressão regular com <code>replace()</code></h3>
+
+<p>No exemplo a seguir foi definida uma expressão regular com a flag "<code>i</code>" (que ignora diferenças entre maiúsculas e minúsculas) no método <code>replace()</code>.</p>
+
+<pre class="notranslate"><code>var str = 'Twas the night before Xmas...';
+var newstr = str.replace(/xmas/i, 'Christmas');
+
+console.log(newstr);
+// retorna "Twas the night before Christmas..."</code></pre>
+
+<div class="blockIndicator note">
+<p><strong>Nota:</strong> Veja <a href="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions" title="https://wiki.developer.mozilla.org/pt-BR/docs/Web/JavaScript/Guide/Regular_Expressions">este guia</a> para maiores explicações as sobre expressões regulares.</p>
+</div>
+
+<h3 id="Usando_global_e_ignore_com_replace">Usando <code>global</code> e <code>ignore</code> com <code>replace()</code></h3>
+
+<p>Substituir globalmente, "<code>g</code>", só pode ser feito com uma expressão regular. No exemplo a seguir, a expressão regular inclui as flags global e ignore que permitem a função <code>replace()</code> substituir cada "<code>maçãs</code>" por "<code>laranjas</code>" na string.</p>
+
+<pre class="notranslate"><code>var re = /maçãs/gi;
+var str = '</code>As maçãs são redondas. As maçãs são suculentas<code>.';
+var newstr = str.replace(re, 'laranjas');
+
+console.log(newstr);
+// retorna
+// "</code>As laranjas são redondas. As laranjas são suculentas<code>."</code></pre>
+
+<h3 id="Trocando_palavras_em_uma_string">Trocando palavras em uma string</h3>
+
+<p>O script a seguir troca as palavras na string. Para o texto que vai substituir, o script usa <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges" title="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions/Groups_and_Ranges">grupos de captura</a> e os padrões de substituição <code>$1</code> e <code>$2</code>.</p>
+
+<pre class="notranslate"><code>var re = /(\w+)\s(\w+)/;
+var str = 'John Smith';
+var newstr = str.replace(re, '$2, $1');
+console.log(newstr);  // Smith, John</code></pre>
+
+<h3 id="Usando_uma_função_que_modifica_os_caracteres_coincidentes">Usando uma função que modifica os caracteres coincidentes</h3>
+
+<div class="tw-ta-container hide-focus-ring tw-nfl" id="tw-target-text-container">
+<p><span lang="pt">Neste exemplo, todas as ocorrências de letras maiúsculas na string são convertidas em minúsculas e um hífen é inserido antes do local de correspondência. </span>O importante aqui é que é necessário uma operação adicional no item antes dele ser retornado como substituído.</p>
+</div>
+
+<p>A função de substituição aceita a string coincidida como parâmetro e usa ela para transformar os caracteres e concatenar um hífen antes de retornar.</p>
+
+<pre class="notranslate"><code>function styleHyphenFormat(propertyName) {
+  function upperToHyphenLower(match, offset, string) {
+    return (offset ? '-' : '') + match.toLowerCase();
+  }
+  return propertyName.replace(/[A-Z]/g, upperToHyphenLower);
+}</code></pre>
+
+<p>Dado o seguinte parâmetro: <code>styleHyphenFormat('borderTop')</code>, o valor retornado é '<code>border-top</code>'.</p>
+
+<p>Como queremos transformar o resultado da coincidencia antes da substituição final, nós devemos usar uma função. Isto força que a transformação seja feita antes da chamada do método {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}. Se tivéssemos tentado isto sem a função, o método {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}} não teria efeito.</p>
+
+<pre class="brush: js example-bad notranslate">let newString = propertyName.replace(/[A-Z]/g, '-' + '$&amp;'.toLowerCase());  // não funciona</pre>
+
+<p>Isso acontece porque <code>'$&amp;'.toLowerCase()</code> será executada antes (resultando no mesmo que <code>'$&amp;'</code>) em vez de usar os caracteres da string a ser transformada.</p>
+
+<h3 id="Substituindo_graus_Fahrenheit_em_Celsius">Substituindo graus Fahrenheit em Celsius</h3>
+
+<p>O exemplo a seguir converte graus Fahrenheit em Celsius. O grau Fahrenheit deve ser um número terminado com "<code>F</code>". A função retorna o número em Celsius terminando em "<code>C</code>". Por exemplo, se o valor de entrada for "<code>212F</code>", a função deve retornar "<code>100C</code>". Se o número for "<code>0F</code>", a função deve retornar "<code>-17.77777777777778C</code>".</p>
+
+<p>A expressão regular <code>test</code> verifica por números que terminem com "<code>F</code>". O número de graus Fahrenheit é acessível pela função pelo segundo parâmetro, <code>p1</code>. A função calcula o Celsius baseado no Fahrenheit passado via string para a função <code>f2c()</code>. A <code>f2c()</code> então retorna o número em Celsius.</p>
+
+<pre class="notranslate"><code>function f2c(x) {
+  function convert(str, p1, offset, s) {
+    return ((p1 - 32) * 5/9) + 'C';
+  }
+  var s = String(x);
+  var test = /(-?\d+(?:\.\d*)?)F\b/g;
+  return s.replace(test, convert);
+}</code></pre>
+
+<h3 id="Use_uma_função_com_expressão_regular_para_evitar_loops_for">Use uma função com expressão regular para evitar loops for</h3>
+
+<p>O exemplo a seguir pega um padrão de string e converte em um array de objetos.</p>
+
+<p><strong>Entrada:</strong></p>
+
+<p>Uma string com caracteres: <code>x</code>, <code>-</code> e <code>_</code></p>
+
+<pre class="notranslate"><code>x-x_
+x---x---x---x---
+x-xxx-xx-x-
+x_x_x___x___x___</code></pre>
+
+<p><strong>Saída:</strong></p>
+
+<p>Um array de objetos. Um <code>'x'</code> denota um estado <code>'on'</code>, um <code>'-'</code> (hífen) denota um estado <code>'off'</code>  e um <code>'_'</code> (underline) denota o comprimento do estado <code>'on'</code>.</p>
+
+<pre class="notranslate"><code>[
+  { on: true, length: 1 },
+  { on: false, length: 1 },
+  { on: true, length: 2 }
+  ...
+]</code></pre>
+
+<p><strong>Código:</strong></p>
+
+<pre class="notranslate"><code>var str = 'x-x_';
+var retArr = [];
+str.replace(/(x_*)|(-)/g, function(match, p1, p2) {
+  if (p1) { retArr.push({ on: true, length: p1.length }); }
+  if (p2) { retArr.push({ on: false, length: 1 }); }
+});
+
+console.log(retArr);</code></pre>
+
+<p>O código gera um array de 3 objetos como desejado sem usar uma função de loop.</p>
+
+<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>ECMAScript 3rd Edition.</td>
+   <td>Standard</td>
+   <td>Defnição inicial. Implementado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.11', 'String.prototype.replace')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.replace', 'String.prototype.replace')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h3>
+
+<ul>
+ <li>Começando no Gecko 27 {{geckoRelease(27)}}, esse método foi ajustado conforme as especificações do ECMAScript. Quando <code>replace()</code> é chamado com uma expressão regular global, a propriedade {{jsxref("RegExp.lastIndex")}} (se especificada) será resetada para <code>0</code> ({{bug(501739)}}).</li>
+</ul>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.match()")}}</li>
+ <li>{{jsxref("RegExp.prototype.exec()")}}</li>
+ <li>{{jsxref("RegExp.prototype.test()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html b/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html
new file mode 100644
index 0000000000..c545573689
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/replaceall/index.html
@@ -0,0 +1,178 @@
+---
+title: String.prototype.replaceAll()
+slug: Web/JavaScript/Reference/Global_Objects/String/replaceAll
+tags:
+  - Expressão Regular
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - regex
+  - replaceAll()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/replaceAll
+---
+<div>{{JSRef}}</div>
+
+<div class="blockIndicator note"><strong>Nota</strong>: A partir de Agosto de 2020, o método <code>replaceAll()</code> continuará sendo suportado pelo Firefox, mas não pelo Chrome. Ele estará disponível somente no Chrome 85.</div>
+
+<p>O método <code>replaceAll()</code> retorna uma nova string com todas as ocorrências de um padrão substituídas por uma substituição. O padrão pode ser uma string ou uma {{jsxref ("RegExp")}}, e a substituição pode ser uma string ou uma função a ser chamada para cada ocorrência.<br>
+ <br>
+ A <em>string</em> original é mantida sem modificação.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-replaceall.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">const newStr = <var>str</var>.replaceAll(<var>regexp</var>|<var>substr</var>, <var>newSubstr</var>|<var>function</var>)
+</pre>
+
+<div class="blockIndicator note">
+<p><strong>Nota</strong>: quando usar uma `<var>regexp</var>`, você deve colocar o sinalizador (flag) global "<code>g</code>". Do contrário, será retornado um <code>TypeError</code>: "<em>replaceAll must be called with a global RegExp</em>".</p>
+</div>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code><var>regexp</var></code> (padrão)</dt>
+ <dd>Uma {{jsxref ("RegExp")}} ou literal com o sinalizador (flag) global. As ocorrências serão substituídas por <em><code>newSubstr</code></em> ou pelo valor retornado da <em><code>function</code></em> (função) especificada.</dd>
+ <dt><code><var>substr</var></code><var> </var>(padrão)</dt>
+ <dd>Uma {{jsxref ("String")}} que deve ser substituída por <code>newSubstr</code>. É tratada como uma string literal e não é interpretada como uma expressão regular (<em><code>RegExp</code></em>).</dd>
+ <dt><code><var>newSubstr</var></code> (substituição)</dt>
+ <dd>É a {{jsxref("String")}} que substitui a <code><em>substring</em></code> especificada pelo parâmetro <code><var>regexp</var></code> ou <code><var>substr</var></code>. Um número de padrões especiais para substituição são suportados; veja a seção "<a href="#">Especificando uma string como parâmetro</a>" abaixo.</dd>
+ <dt><code><var>function</var></code> (substituição)</dt>
+ <dd>Uma função a ser chamada retornando a nova <code><em>substring</em></code> a ser usada para substituir as correspondências para a dada <code><var>regexp</var></code> ou <code><var>substr</var></code>. Os argumentos passados para esta função são descritos na seção "<a href="#Especificando uma função como parâmetro">Especificando uma função como parâmetro</a>" abaixo.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Um nova <em>string</em>, com todas as ocorrências de um padrão substituído por uma substituição.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Este método não muda o objeto {{jsxref("String")}} original. Ele simplesmente retorna uma nova <em>string</em>.</p>
+
+<h3 id="Especificando_uma_string_como_parâmetro"><a id="Especificando uma string como parâmetro" name="Especificando uma string como parâmetro">Especificando uma string como parâmetro</a></h3>
+
+<p>A <em>string</em> de substituição pode incluir os seguimentos padrões especiais de substituição:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th class="header" scope="col">Padrão</th>
+   <th class="header" scope="col">Insere</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><code>$$</code></td>
+   <td>Insere um <code>"$"</code>.</td>
+  </tr>
+  <tr>
+   <td><code>$&amp;</code></td>
+   <td>Insere a <em>substring</em> correspondente.</td>
+  </tr>
+  <tr>
+   <td><code>$`</code></td>
+   <td>Insere a porção da <em>string</em> que precede a <em>substring</em> correspondente.</td>
+  </tr>
+  <tr>
+   <td><code>$'</code></td>
+   <td>Insere a porção da <em>string</em> que sucede a <em>substring</em> correspondente.</td>
+  </tr>
+  <tr>
+   <td><code>$<var>n</var></code></td>
+   <td>Onde <code><var>n</var></code> é um inteiro positivo menor que 100, insere a <var><code>n</code></var>-ésima <em>string</em> submatch entre parênteses, desde que o primeiro argumento seja um objeto {{jsxref("RegExp")}}. Note que isso é indexado começando pelo <code>1</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h3 id="Especificando_uma_função_como_parâmetro"><a id="Especificando uma função como parâmetro" name="Especificando uma função como parâmetro">Especificando uma função como parâmetro</a></h3>
+
+<p>Você pode especificar uma função como segundo parâmetro. Neste caso, a função será chamada depois da ocorrência ter sido encontrada. O resultado da função (valor de retorno) será usado como uma <em>string</em> para substituição. (<strong>Nota:</strong> Os padrões especiais mencionados acima <strong>não se aplicam </strong>neste caso.)</p>
+
+<p>Note que a função será chamada múltiplas vezes para cada ocorrência a ser substituída se a expressão regular no primeiro parâmetro for global "<code>g</code>".</p>
+
+<p>Os argumentos para funções são os seguintes:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th class="header" scope="col">Nome possível</th>
+   <th class="header" scope="col">Valor fornecido</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><code>match</code></td>
+   <td>A <em>substring</em> correspondida. (Corresponde ao <code>$&amp;</code> acima.)</td>
+  </tr>
+  <tr>
+   <td><code>p1, p2, ...</code></td>
+   <td>A <var>n</var>-ésima string encontrada por um grupo de captura entre parênteses, desde que o primeiro argumento para <code>replace()</code> seja uma {{jsxref("RegExp")}}. (Corresponde a <code>$1</code>, <code>$2</code>, etc. acima.) Por exemplo, se <code>/(\a+)(\b+)/</code>, foi dado, <code>p1</code> é a correspondência para <code>\a+</code>, e <code>p2</code> para <code>\b+</code>.</td>
+  </tr>
+  <tr>
+   <td><code>offset</code></td>
+   <td>O deslocamento da substring correspondente em toda a string sendo examinada. (Por exemplo, se toda a string for '<code>abcd</code>' e a substring correspondente for '<code>bc</code>', este argumento será <code>1</code>.)</td>
+  </tr>
+  <tr>
+   <td><code>string</code></td>
+   <td>A <em>string</em> inteira será examinada.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>(O número exato de argumentos depende se o primeiro argumento é um objeto {{jsxref("RegExp")}} — e, se então, quantas <em>subcorrespondências </em>entre parênteses são especificadas.)</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_replaceAll">Usando <code>replaceAll()</code></h3>
+
+<pre class="brush: js notranslate">'aabbcc'.replaceAll('b', '.');
+// 'aa..cc'</pre>
+
+<h3 id="RegExp_sem_flag_g_retorando_erro">RegExp sem flag "g" retorando erro</h3>
+
+<p>Ao usar uma expressão regular para realizar uma pesquisa, a mesma deve conter a flag global "<code>g</code>". O código abaixo não irá funcionar:</p>
+
+<pre class="brush: js; example-bad notranslate">'aabbcc'.replaceAll(/b/, '.');
+TypeError: replaceAll must be called with a global RegExp
+</pre>
+
+<p>Já o código abaixo vai funcionar:</p>
+
+<pre class="brush: js; example-good notranslate">'aabbcc'.replaceAll(/b/g, '.');
+"aa..cc"
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.replaceall', 'String.prototype.replaceAll')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.replaceAll")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.replace", "String.prototype.replace()")}}</li>
+ <li>{{jsxref("String.prototype.match", "String.prototype.match()")}}</li>
+ <li>{{jsxref("RegExp.prototype.exec", "RegExp.prototype.exec()")}}</li>
+ <li>{{jsxref("RegExp.prototype.test", "RegExp.prototype.test()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/search/index.html b/files/pt-br/web/javascript/reference/global_objects/string/search/index.html
new file mode 100644
index 0000000000..0abfec19df
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/search/index.html
@@ -0,0 +1,153 @@
+---
+title: String.prototype.search()
+slug: Web/JavaScript/Reference/Global_Objects/String/search
+tags:
+  - Expressões Regulares
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - search()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/search
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>search()</code> realiza uma busca por uma ocorrência entre uma expressão regular e uma {{jsxref ("String")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>str</var>.search(<var>regexp</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>regexp</code></dt>
+ <dd>Um objeto contendo uma expressão regular. Se um objeto <code>obj</code> for passado como parâmetro e não for do tipo <code>RegExp</code>, ele será implicitamente convertido para uma {{jsxref("RegExp")}} através da instrução <code>new RegExp(obj)</code>.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>O índice na string do primeiro trecho que satisfaz a expressão regular. Do contrário, o valor <code>-1</code><strong> </strong>será retornado.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Quando você quiser saber se um padrão foi encontrado, e também saber seu índice dentro de uma string, use <code>search()</code>. (Se você deseja apenas saber se ele existe, use o método semelhante {{jsxref ("RegExp.prototype.test()", "test()")}} do protótipo RegExp, que retorna um booleano.)</p>
+
+<p>Para obter mais informações (mas em compensação a execução se torna mais lenta), use {{jsxref ("String.prototype.match()", "match()")}} (semelhante ao método {{jsxref ("RegExp.prototype.exec()" , "exec()")}} da RegExp).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_search">Usando <code>search()</code></h3>
+
+<p>O exemplo a seguir pesquisa uma string com dois objetos <code>regexp</code> diferentes para mostrar uma pesquisa bem-sucedida (valor positivo) vs. uma pesquisa mal-sucedida (-1).</p>
+
+<pre class="brush: js notranslate">let str = "hey JudE"
+let re = /[A-Z]/g
+let reDot = /[.]/g
+console.log(str.search(re))    // retorna 4, que é o índice da primeira letra maiúscula "J"
+console.log(str.search(reDot)) // retorna -1 pois não conseguiu encontrar o ponto "."</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário(s)</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.12', 'String.prototype.search')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.search', 'String.prototype.search')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.search', 'String.prototype.search')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_específicas_para_a_engine_Gecko">Notas específicas para a engine Gecko</h2>
+
+<ul>
+ <li>Antes do {{Gecko("8.0")}}, <code>search()</code> foi implementado incorretamente. Quando era chamadosem parâmetros ou com {{jsxref("undefined")}}, ele buscava pela string '<code>undefined</code>', ao invés de buscar pela string vazia. Isto foi corrigido. Agora <code>'a'.search()</code> e <code>'a'.search(undefined)</code> corretamente retornam 0.</li>
+ <li>A partir do Gecko 39 {{geckoRelease(39)}}, o argumento não-padrão <code>flags</code> está defasado (deprecated) e dispara um aviso no console ({{bug(1142351)}}).</li>
+ <li>A partir do Gecko 47 {{geckoRelease(47)}}, o argumento não-padrão <code>flags</code> não é mais suportado em builds <em>non-release</em> e em breve será removido inteiramente ({{bug(1245801)}}).</li>
+ <li>A partir do Gecko 49 {{geckoRelease(49)}}, o argumento não-padrão <code>flags</code> não é mais suportado ({{bug(1108382)}}).</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.match()")}}</li>
+ <li>{{jsxref("RegExp.prototype.exec()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/slice/index.html b/files/pt-br/web/javascript/reference/global_objects/string/slice/index.html
new file mode 100644
index 0000000000..74d6819506
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/slice/index.html
@@ -0,0 +1,233 @@
+---
+title: String.prototype.slice()
+slug: Web/JavaScript/Reference/Global_Objects/String/slice
+tags:
+  - JavaScript
+  - Prototipo
+  - Reference
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/slice
+---
+<div>{{JSRef("Global_Objects", "String")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O método <code>slice()</code> extrai uma parte de uma string e a retorna como uma nova string, sem modificar a string original.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.slice(<var>startIndex</var>[, <var>endIndex</var>])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Paramêtros</h3>
+
+<dl>
+ <dt><code>startIndex</code></dt>
+ <dd>É o índice, de base zero, onde se inicia a extração. Se for um número negativo, será o mesmo que executar <em><code>str.length + startIndex</code></em> (por exemplo, se <em><code>startIndex</code></em> for <em><code>-3</code></em>, será o mesmo que executar <em><code>str.length - 3</code></em>).</dd>
+ <dd>
+ <pre class="brush: js notranslate">const nome = 'Ricardo';
+console.log(nome.slice(-3)); // retorna 'rdo'</pre>
+ </dd>
+</dl>
+
+<dl>
+ <dd>Se <em><code>startIndex</code></em> for maior ou igual a <code><var>str</var><em>.length</em></code>, uma string vazia será retornada.</dd>
+ <dd>
+ <pre class="brush: js notranslate">const nome = 'Ricardo';
+console.log(nome.slice(7)); // retorna &lt;empty string&gt;'
+</pre>
+ </dd>
+ <dt><code>endIndex</code></dt>
+ <dd>Opcional. É o índice, de base zero, onde termina a extração. O caractere que possuir este índice não será incluso.</dd>
+ <dd>Se omitido ou possuir valor de <em><code>undefined</code></em>, ou for maior que <code><var>str</var><em>.length</em></code>, <em><code>slice()</code></em> extrairá até o fim da string.</dd>
+ <dd>
+ <pre class="brush: js notranslate">const nome = 'Ricardo';
+
+// omitindo fimSlice
+console.log(nome.slice(0)); // retorna 'Ricardo'
+
+// undefined fimSlice
+let i; // variável criada sem atribuir valor
+console.log(nome.slice(0, i)); // retorna 'Ricardo'
+
+// passando número maior que o tamanho da string
+console.log(nome.slice(0, 7)); // retorna 'Ricardo'</pre>
+ </dd>
+ <dd>Se negativo, é o mesmo que executar <em><code>str.length + endIndex</code></em> onde <em><code>str.length</code></em> é o tamanho da string (por exemplo, se <em><code>endIndex</code></em> é <em><code>-3</code></em>, é como executar <code><em>str.length - 3</em></code>).</dd>
+</dl>
+
+<dl>
+ <dd>
+ <pre class="brush: js notranslate">const nome = 'Ricardo';<strong>
+</strong>console.log(nome.slice(0, -3)); // retorna 'Rica'
+</pre>
+ </dd>
+ <dd>Se for um valor diferente de indefinido e, ao mesmo tempo não for um número, uma string vazia será retornada</dd>
+ <dd>
+ <pre class="brush: js notranslate">const nome = 'Ricardo';
+let i; // variável criada sem valor atribuído
+
+// passando algum valor ≠ de undefined e ≠ de número
+console.log(nome.slice(0, NaN)); // retorna &lt;empty string&gt;
+console.log(nome.slice(2, false)); // retorna &lt;empty string&gt;
+console.log(nome.slice(5, i)); // retorna 'Ricardo'
+</pre>
+
+ <p>Se <code><var>endIndex</var></code> for definido e <code><var>startIndex</var></code> for negativo, <code><var>endIndex</var></code> deve ser negativo também, do contrário uma string vazia é retornada.</p>
+
+ <pre class="brush: js notranslate">const nome = 'Ricardo';
+console.log(nome.slice(-3, 0)); // retorna &lt;empty string&gt;
+</pre>
+
+ <p>Caso <code><var>endIndex</var></code> seja definido e <code><var>startIndex</var></code> e <code><var>endIndex</var></code> sejam ambos positivos ou negativos, <code><var>endIndex</var></code> deve ser maior que <code><var>startIndex</var></code>, do contrário uma string vazia é retornada.</p>
+
+ <pre class="brush: js notranslate">const nome = 'Ricado';
+console.log(nome.slice(-1, -3)); // retorna &lt;empty string&gt;
+console.log(nome.slice(3, 1)); // retorna &lt;empty string&gt;
+</pre>
+ </dd>
+</dl>
+
+<h3 id="Retorno">Retorno</h3>
+
+<p>Uma nova string contento a porção extraída da string.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><em><code>slice()</code></em> extrai um texto de uma string e retorna uma nova string. Modificações realizadas no texto de uma string não afetam a outra string.</p>
+
+<p><em><code>slice()</code></em> extrai até, mas não inclue <em><code>endIndex</code>.</em><br>
+ <br>
+ <code><em>str.slice(1, 4)</em></code> extrai a partir do segundo caractere até o quarto caractere (ou seja, os caracteres de índices <em><code>1</code></em>, <em><code>2</code></em>, e <em><code>3</code></em>).</p>
+
+<p>Por exemplo, <em><code>str.slice(2, -1)</code></em> extrai a partir do terceiro carácter até o penúltimo caractere da string.</p>
+
+<pre class="brush: js notranslate">const nome = 'Ricardo';
+console.log(nome.slice(2, -1)); // retorna 'card'
+</pre>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Using_slice_to_create_a_new_string" name="Example:_Using_slice_to_create_a_new_string">Exemplo: Usando <code>slice()</code> para criar uma nova string</h3>
+
+<p>O exemplo a seguir usa <em><code>slice()</code></em> para criar uma nova string.</p>
+
+<pre class="brush: js notranslate">var str1 = 'A manhã está sobre nós', // o tamanho de str1 é 22
+    str2 = str1.slice(3, 10),
+    str3 = str1.slice(2, -2),
+    str4 = str1.slice(13),
+    str5 = str1.slice(22);
+console.log(str2); // retorna 'anhã es'
+console.log(str3); // retorna 'manhã está sobre n'
+console.log(str4); // retorna 'sobre nós'
+console.log(str5); // retorna &lt;empty string&gt;
+</pre>
+
+<h3 id="Example_Using_slice_with_negative_indexes" name="Example:_Using_slice_with_negative_indexes">Exemplo: Usando <code>slice()</code> com índices negativos.</h3>
+
+<p>O exemplo a seguir usa o <em><code>slice()</code></em> com índices negativos.</p>
+
+<pre class="brush: js notranslate">var str = 'A manhã está sobre nós';
+str.slice(-3);     // retorna 'nós'
+str.slice(-3, -1); // retorna 'nó'
+str.slice(0, -1);  // retorna 'A manhã está sobre nó'
+</pre>
+
+<p>O exemplo abaixo percorre o índice no sentido anti-horário (de trás para frente) até chegar ao índice 11 da string, que será o início. Logo após, percorre o índice da string no sentido horário até chegar ao índice 16 da string, que será o fim.</p>
+
+<pre class="brush: js notranslate">console.log(str.slice(-11, 16)) // retorna "á sob"</pre>
+
+<p>O exemplo abaixo percorre o índice no sentido horário até chegar ao índice 10 da string, que será o início. Logo após, percorre o índice da string no sentido anti-horário até chegar ao índice 7 da string, que será o fim.</p>
+
+<pre class="brush: js notranslate">console.log(str.slice(10, -7)) // retorna "tá so"</pre>
+
+<p>O exemplo abaixo percorre o índice no sentido anti-horário até chegar ao índice 5 da string, que será o início. Logo após, percorre o índice da string novamente no sentido anti-horário até chegar ao índice 1 da string, que será o fim.</p>
+
+<pre class="brush: js notranslate">console.log(str.slice(-5, -1)) // retorna "e nó"</pre>
+
+<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 3rd Edition.</td>
+   <td>Standard</td>
+   <td>Initial definition. Implemented in JavaScript 1.2.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.13', 'String.prototype.slice')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.slice', 'String.prototype.slice')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_Browsers">Compatibilidade entre Browsers</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.substr()")}}</li>
+ <li>{{jsxref("String.prototype.substring()")}}</li>
+ <li>{{jsxref("Array.prototype.slice()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/small/index.html b/files/pt-br/web/javascript/reference/global_objects/string/small/index.html
new file mode 100644
index 0000000000..2983a5c9fc
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/small/index.html
@@ -0,0 +1,72 @@
+---
+title: String.prototype.small()
+slug: Web/JavaScript/Reference/Global_Objects/String/small
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - small()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/small
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code>small()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small">&lt;small&gt;</a></code> que faz com que uma string seja exibida em uma fonte pequena.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.small()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/small">&lt;small&gt;</a></code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>small()</code> cria uma string dentro de uma tag <code>&lt;small&gt;</code>: <code>"&lt;small&gt;str&lt;/small&gt;"</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_small">Usando <code>small()</code></h3>
+
+<p>O exemplo a seguir usa métodos do objeto global String para alterar o tamanho da string:</p>
+
+<pre class="brush: js notranslate">var worldString = 'Olá, mundo';
+
+console.log(worldString.small());     // &lt;small&gt;Olá, mundo&lt;/small&gt;
+console.log(worldString.big());       // &lt;big&gt;Olá, mundo&lt;/big&gt;
+console.log(worldString.fontsize(7)); // &lt;font size="7"&gt;Olá, mundo&lt;/fontsize&gt;
+</pre>
+
+<p>Com o objeto <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style" title="https://wiki.developer.mozilla.org/en-US/docs/Web/API/ElementCSSInlineStyle/style">element.style</a> você pode pegar o atributo de estilo do elemento e manipulá-lo de forma mais genérica, por exemplo:</p>
+
+<pre class="brush: js notranslate">document.getElementById('#oIdDoElemento').style.fontSize = '0.7em';
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.small', 'String.prototype.small')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.small")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.fontsize()")}}</li>
+ <li>{{jsxref("String.prototype.big()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/split/index.html b/files/pt-br/web/javascript/reference/global_objects/string/split/index.html
new file mode 100644
index 0000000000..80b42f28e0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/split/index.html
@@ -0,0 +1,282 @@
+---
+title: String.prototype.split()
+slug: Web/JavaScript/Reference/Global_Objects/String/split
+tags:
+  - Expressões Regulares
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - split()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/split
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>split()</code> divide uma {{jsxref ("String")}} em uma lista ordenada de substrings, coloca essas substrings em um array e retorna o array. A divisão é feita procurando um padrão, onde o padrão é fornecido como o primeiro parâmetro na chamada do método.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.split([separator[, limit]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<ul>
+ <li>O caso mais simples é quando o separador é apenas um único caractere que será usado para dividir a string. Por exemplo, uma string contendo valores separados por tabulação (TSV) poderia ser analisada passando um caractere de tabulação como separador, como este: myString.split ("\ t").</li>
+ <li>Se o <code>separator</code> contiver vários caracteres, toda a sequência de caracteres deve ser encontrada para ser dividida.</li>
+ <li>Se o <code>separator</code> for omitido ou não aparecer dentro da <code>str</code>, o array retornará um elemento consistindo em toda a string.</li>
+ <li>Se o <code>separator</code> aparecer no início (ou no final) da string, ele ainda terá o efeito de divisão. O resultado é uma string vazia (ou seja, <code>str.length == 0</code>), que aparece na primeira (ou última) posição do array retornado.</li>
+ <li>Se o <code>separator</code> for uma string vazia (""), <code>str</code> será convertido em um array contendo cada um de seus caracteres em UTF-16.</li>
+</ul>
+
+<dl>
+ <dt><code>separator</code></dt>
+ <dd>Opcional. Especifica o caractere, ou conjunto de caracteres, a ser usado para separar a string. O separador pode ser uma string ou uma {{jsxref("Global_Objects/RegExp", "expressão regular", "", 1)}}.</dd>
+</dl>
+
+<div class="blockIndicator warning">
+<p><strong>Aviso:</strong> Quando uma string vazia (<code>""</code>) é usada como separador, a string não é dividida por caracteres percebidos pelo usuário (<a href="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries" title="https://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries">grapheme clusters</a>) ou caracteres Unicode (pontos de código), mas por unidades de código UTF-16. Isso destrói <a href="http://unicode.org/faq/utf_bom.html#utf16-2" title="http://unicode.org/faq/utf_bom.html#utf16-2">pares substitutos</a>. Consulte “<a href="https://stackoverflow.com/questions/4547609/how-do-you-get-a-string-to-a-character-array-in-javascript/34717402#34717402" title="https://stackoverflow.com/questions/4547609/how-do-you-get-a-string-to-a-character-array-in-javascript/34717402#34717402">Como você transforma uma string em um array de caracteres em JavaScript?” no StackOverflow</a>.</p>
+</div>
+
+<dl>
+ <dt><code>limite</code></dt>
+ <dd>
+ <p>Opcional. Um número inteiro não negativo especificando um limite no número de divisões a serem encontradas. O método <code>split()</code> ainda dividirá em cada ocorrência do separador, até que o número de itens divididos corresponda ao limite ou que a string fique aquém do separador.</p>
+
+ <ul>
+  <li>O array pode conter menos entradas do que o <code>limit</code> se o final da string for alcançado antes que o limite seja atingido.</li>
+  <li>Se o <code>limit</code> for <code>0</code>, <code>[]</code> será retornado.</li>
+ </ul>
+ </dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Um array de strings divididos em cada ponto onde o separador ocorre na string informada.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Quando encontrado, o caractere designado como o <code>separator</code> é removido da string e as substrings são retornadas em um array. Se o <code>separator</code> não for encontrado ou for omitido, o array irá conter um elemento consistindo da string inteira. Se o <code>separator</code> for uma string vazia, <code>str</code> será convertida em um array de caracteres.</p>
+
+<p>Se o separador for uma expressão regular que contenha parênteses de captura, cada vez que o <code>separator</code> for encontrado, os resultados (incluindo qualquer resultado <code>undefined</code>) dos parênteses de captura serão emendados ao array de saída. Entretanto, nem todos os navegadores possuem suporte a isso.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_split">Usando <code>split()</code></h3>
+
+<p>Quando a string está vazia, o <code>split()</code> irá retornar um array contendo uma string vazia ao invés de um array vazio. Se a string e o separador forem ambos strings vazias, um array vazio será retornado.</p>
+
+<pre class="brush: js notranslate">const myString = ''
+const splits = myString.split()
+
+console.log(splits);
+
+// retorna [""]</pre>
+
+<p>O exemplo a seguir define uma função que divide uma string em um array de strings usando o separador especificado. Depois de dividir a string, a função exibe mensagens indicando a string original (antes da divisão), o separador usado, o número de elementos no array e os elementos individuais do array.</p>
+
+<pre class="brush: js notranslate">function splitString(stringToSplit, separator) {
+  var arrayOfStrings = stringToSplit.split(separator);
+
+  console.log('A string original é: "' + stringToSplit + '"');
+  console.log('O separador é: "' + separator + '"');
+  console.log('O array tem ' + arrayOfStrings.length + ' elementos: ' + arrayOfStrings.join(' / '));
+}
+
+var tempestString = 'Oh brave new world that has such people in it.';
+var monthString = 'Jan,Fev,Mar,Abr,Mai,Jun,Jul,Ago,Set,Out,Nov,Dez';
+
+var space = ' ';
+var comma = ',';
+
+splitString(tempestString, space);
+splitString(tempestString);
+splitString(monthString, comma);
+</pre>
+
+<p>Esse exemplo produz a saída a seguir:</p>
+
+<pre class="notranslate">A string original é: "Oh brave new world that has such people in it."
+O separador é: " "
+O array possui 10 elementos: Oh / brave / new / world / that / has / such / people / in / it.
+
+A string original é: "Oh brave new world that has such people in it."
+O separador é: "undefined"
+O array possui 1 elementos: Oh brave new world that has such people in it.
+
+A string original é: "Jan,Feb,Mar,Apr,May,Jun,Jul,Aug,Sep,Oct,Nov,Dec"
+O separador é: ","
+O array possui 12 elementos: Jan / Feb / Mar / Apr / May / Jun / Jul / Aug / Sep / Oct / Nov / Dec
+</pre>
+
+<h3 id="Removendo_espaços_de_uma_string">Removendo espaços de uma string</h3>
+
+<p>No exemplo a seguir, <code>split()</code> procura por 0 ou mais espaços seguidos por um ponto e vírgula seguido por 0 ou mais espaços e, quando encontrar, remove os espaços e os pontos e vírgulas da string.  <code>nameList</code> é o array retornado como resultado do <code>split()</code>.</p>
+
+<pre class="brush: js notranslate">var names = 'Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand ';
+
+console.log(names);
+
+var re = /\s*;\s*/;
+var nameList = names.split(re);
+
+console.log(nameList);
+</pre>
+
+<p>O retorno do código acima são duas linhas. A primeira linha registra a string original e a segunda linha registra o array resultante.</p>
+
+<pre class="notranslate">Harry Trump ;Fred Barney; Helen Rigby ; Bill Abel ;Chris Hand
+[ "Harry Trump", "Fred Barney", "Helen Rigby", "Bill Abel", "Chris Hand " ]
+</pre>
+
+<h3 id="Retornando_um_número_limitado_de_divisões">Retornando um número limitado de divisões</h3>
+
+<p>No exemplo a seguir, o <code>split()</code> procura por 0 ou mais espaços em uma string e retorna as 3 primeiras divisões que encontrar.</p>
+
+<pre class="brush: js notranslate">var myString = 'Hello World. How are you doing?';
+var splits = myString.split(' ', 3);
+
+console.log(splits);
+</pre>
+
+<p>O script exibirá o texto a seguir:</p>
+
+<pre class="notranslate">["Hello", "World.", "How"]
+</pre>
+
+<h3 id="Parênteses_de_Captura">Parênteses de Captura</h3>
+
+<p>Se o <code>separator</code> contém parênteses de captura, os resultados correspondentes são retornados no array.</p>
+
+<pre class="brush: js notranslate">var myString = 'Hello 1 word. Sentence number 2.';
+var splits = myString.split(/(\d)/);
+
+console.log(splits);
+</pre>
+
+<p>O script exibirá o texto a seguir:</p>
+
+<pre class="notranslate">[ "Hello ", "1", " word. Sentence number ", "2", "." ]
+</pre>
+
+<div class="blockIndicator note">
+<p><strong>Nota: </strong><code>\d</code> corresponde à classe de caracteres para dígitos entre 0 e 9.</p>
+</div>
+
+<h3 id="Revertendo_uma_String_usando_split">Revertendo uma String usando <code>split()</code></h3>
+
+<div class="blockIndicator warning">
+<p>Esta não é a mlehor maneira de reverter uma string:</p>
+
+<pre class="brush: js example-bad notranslate">const str = 'asdfghjkl'
+const strReverse = str.split('').reverse().join('')
+// 'lkjhgfdsa'
+
+// split() retorna um array onde os métodos
+// reverse() e join() podem ser aplicados</pre>
+
+<p>Não funciona se a string contém <code>grapheme clusters</code>, mesmo ao usar uma divisão compatível com Unicode. (Use, por exemplo, <a href="https://github.com/mathiasbynens/esrever" title="https://github.com/mathiasbynens/esrever">esrever</a> no lugar.)</p>
+
+<pre class="brush: js example-bad notranslate">const str = 'résumé'
+const strReverse = str.split(/(?:)/u).reverse().join('')
+// retorna "́emuśer"</pre>
+
+<p><strong>Bonus:</strong> use o operador {{jsxref("Operators/Comparison_Operators", "===", "#Identity_strict_equality_(===)")}} para testar se a string original era um palíndromo.</p>
+</div>
+
+
+
+<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('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.14', 'String.prototype.split')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.split', 'String.prototype.split')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.split', 'String.prototype.split')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="sect1"></h2>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.charAt()")}}</li>
+ <li>{{jsxref("String.prototype.indexOf()")}}</li>
+ <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
+ <li>{{jsxref("Array.prototype.join()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html b/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html
new file mode 100644
index 0000000000..899b331458
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/startswith/index.html
@@ -0,0 +1,96 @@
+---
+title: String.prototype.startsWith()
+slug: Web/JavaScript/Reference/Global_Objects/String/startsWith
+tags:
+  - Começa com
+  - ECMAScript6
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - startsWith()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/startsWith
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>startsWith()</code></strong> determina se uma string começa com os caracteres especificados, retornando <code>true</code> ou <code>false</code>.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/string-startswith.html")}}</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.startsWith(<var>searchString</var>[, <var>position</var>])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><em><code>searchString</code></em></dt>
+ <dd>Os caracteres a serem procurados a partir do início dessa string.</dd>
+ <dt><em><code>position</code></em></dt>
+ <dd>Opcional. A posição nessa string na qual se inicia a busca pela <em><code>searchString</code></em>. O valor padrão é <code>0</code>.</dd>
+ <dt>
+ <h3 id="Valor_retornado">Valor retornado</h3>
+ </dt>
+</dl>
+
+<p><strong><code>true</code></strong> se os caracteres fornecidos forem encontrados no início da string. Se não, <strong><code>false</code></strong>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Esse método permite determinar se uma string começa ou não com outra string. Esse método é case-sensitive (difere maiúsculas de minúsculas, e vice-versa).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_startsWith">Usando <code>startsWith()</code></h3>
+
+<pre class="brush: js notranslate">//startswith
+let str = 'Ser ou não ser, eis a questão.';
+
+console.log(str.startsWith('Ser'))          // true
+console.log(str.startsWith('não ser'))      // false
+console.log(str.startsWith('não ser', 7))  // true
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Este método foi adicionaldo à especificação ECMAScript 2015 e pode ainda não estar disponível em todas as implementações do JavaScript. No entanto, você pode usar o polyfill <code>String.prototype.startsWith()</code> adicionando o seguinte código:</p>
+
+<pre class="notranslate">if (!String.prototype.startsWith) {
+    Object.defineProperty(String.prototype, 'startsWith', {
+        value: function(search, rawPos) {
+            var pos = rawPos &gt; 0 ? rawPos|0 : 0;
+            return this.substring(pos, pos + search.length) === search;
+        }
+    });
+}</pre>
+
+<p>Um polyfill mais robusto (totalmente conforme com a especificação ES2015), mas com menor desempenho e compacto está disponível <a href="https://github.com/mathiasbynens/String.prototype.startsWith">no GitHub por Mathias Bynens</a>.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.startswith', 'String.prototype.startsWith')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{Compat("javascript.builtins.String.startsWith")}}</div>
+
+<div id="compat-mobile"></div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.endsWith()")}}</li>
+ <li>{{jsxref("String.prototype.includes()")}}</li>
+ <li>{{jsxref("String.prototype.indexOf()")}}</li>
+ <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/strike/index.html b/files/pt-br/web/javascript/reference/global_objects/string/strike/index.html
new file mode 100644
index 0000000000..004f93b675
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/strike/index.html
@@ -0,0 +1,68 @@
+---
+title: String.prototype.strike()
+slug: Web/JavaScript/Reference/Global_Objects/String/strike
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - String
+  - metodo
+  - strike()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/strike
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code>strike()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike">&lt;strike&gt;</a></code> que faz com que uma string seja exibida com o texto riscado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.strike()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/strike">&lt;strike&gt;</a></code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>strike()</code> cria uma string dentro uma tag <code>&lt;strike&gt;</code>: "<code>&lt;strike&gt;str&lt;/strike&gt;</code>".</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_strike">Usando <code>strike()</code></h3>
+
+<p>O exemplo a seguir usa métodos do objeto global String para alterar a formatação da string:</p>
+
+<pre class="brush: js notranslate">var worldString = 'Olá, mundo';
+
+console.log(worldString.blink()); // &lt;blink&gt;Olá, mundo&lt;/blink&gt;
+console.log(worldString.bold()); // &lt;b&gt;Olá, mundo&lt;/b&gt;
+console.log(worldString.italics()); // &lt;i&gt;Olá, mundo&lt;/i&gt;
+console.log(worldString.strike()); // &lt;strike&gt;Olá, mundo&lt;/strike&gt;
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.strike', 'String.prototype.strike')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.strike")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.blink()")}}</li>
+ <li>{{jsxref("String.prototype.bold()")}}</li>
+ <li>{{jsxref("String.prototype.italics()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/sub/index.html b/files/pt-br/web/javascript/reference/global_objects/string/sub/index.html
new file mode 100644
index 0000000000..69289bd133
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/sub/index.html
@@ -0,0 +1,123 @@
+---
+title: String.prototype.sub()
+slug: Web/JavaScript/Reference/Global_Objects/String/sub
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - String
+  - metodo
+  - sub()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/sub
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code>sub()</code> cria um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub">&lt;sub&gt;</a></code> que faz com que uma string seja exibida como subscrito (texto pequeno).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.sub()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sub">&lt;sub&gt;</a></code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>sub()</code> cria uma string dentro de uma tag <code>&lt;sub&gt;</code>: <code>"&lt;sub&gt;str&lt;/sub&gt;"</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_os_métodos_sub_e_sup">Usando os métodos <code>sub()</code> e <code>sup()</code></h3>
+
+<p>Os exemplos seguintes usam o métodos <code>sub()</code> e {{jsxref("String.prototype.sup()", "sup()")}} para formatar uma string:</p>
+
+<pre class="brush: js notranslate">var superText = 'superscript';
+var subText = 'subscript';
+
+console.log('This is what a ' + superText.sup() + ' looks like.');
+// This is what a &lt;sup&gt;superscript&lt;/sup&gt; looks like
+
+console.log('This is what a ' + subText.sub() + ' looks like.');
+// This is what a &lt;sub&gt;subscript&lt;/sub&gt; looks like.
+</pre>
+
+<h2 id="Especificação">Especificação</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-string.prototype.sub', 'String.prototype.sub')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.sub', 'String.prototype.sub')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("1.0")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("1.0")}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.sup()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/substr/index.html b/files/pt-br/web/javascript/reference/global_objects/string/substr/index.html
new file mode 100644
index 0000000000..c1e45beaef
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/substr/index.html
@@ -0,0 +1,140 @@
+---
+title: String.prototype.substr()
+slug: Web/JavaScript/Reference/Global_Objects/String/substr
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - substr()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/substr
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>substr()</code> retorna uma parte da string, começando no índice especificado e estendendo-se por um determinado número de caracteres posteriormente.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-substr.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>str</var>.substr(<var>start</var>[, <var>length</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>start</code></dt>
+ <dd>Local para começar a extrair os caracteres.</dd>
+ <dt><code>length</code></dt>
+ <dd>Opcional. O número de caracteres a serem extraídos.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>Uma nova string contendo a seção extraída da string fornecida.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>substr()</code> extrai caracteres de comprimento de uma <code>str</code>, contando a partir do índice inicial.</p>
+
+<ul>
+ <li>Se o <code>start</code> for um número positivo, o índice começa a contar no início da string. Seu valor é limitado ao tamanho da string (<code>str.length</code>).</li>
+ <li>Se o <code>start</code> for um número negativo, o índice começa a contar a partir do final da string. Seu valor é limitado ao tamanho da string (<code>-str.length</code>).</li>
+</ul>
+
+<div class="blockIndicator note">
+<p><strong>Nota</strong>: No Microsoft JScript, valores negativos no argumento <code>start</code> não são considerados como referência ao final da string.</p>
+</div>
+
+<ul>
+ <li>Se <code>length</code> for omitido, <code>substr()</code> extrairá caracteres até o final da string.</li>
+ <li>Se <code>length</code> for {{jsxref("undefined")}}, <code>substr()</code> extrai os caracteres até o final da string.</li>
+ <li>Se <code>length</code> for um número negativo, ele será tratado como <code>0</code>.</li>
+ <li>Para <code>start</code> e <code>length</code>, {{jsxref("NaN")}} é tratado como 0.</li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_substr">Usando <code>substr()</code></h3>
+
+<pre class="brush: js notranslate">var aString = 'Mozilla';
+
+console.log(aString.substr(0, 1));   // 'M'
+console.log(aString.substr(1, 0));   // ''
+console.log(aString.substr(-1, 1));  // 'a'
+console.log(aString.substr(1, -1));  // ''
+console.log(aString.substr(-3));     // 'lla'
+console.log(aString.substr(1));      // 'ozilla'
+console.log(aString.substr(-20, 2)); // 'Mo'
+console.log(aString.substr(20, 2));  // ''</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>JScript da Microsoft não suporta valores negativos para o índice de <code>start</code>. Se você deseja usar esse recurso, você pode usar o seguinte código de compatibilidade para evitar esse erro:</p>
+
+<pre class="brush: js notranslate">// only run when the substr() function is broken
+if ('ab'.substr(-1) != 'b') {
+  /**
+   *  Get the substring of a string
+   *  @param  {integer}  start   where to start the substring
+   *  @param  {integer}  length  how many characters to return
+   *  @return {string}
+   */
+  String.prototype.substr = function(substr) {
+    return function(start, length) {
+      // call the original method
+      return substr.call(this,
+      	// did we get a negative start, calculate how much it is from the beginning of the string
+        // adjust the start parameter for negative value
+        start &lt; 0 ? this.length + start : start,
+        length)
+    }
+  }(String.prototype.substr);
+}
+</pre>
+
+<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>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Defined in the (informative) Compatibility Annex B. Implemented in JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-B.2.3', 'String.prototype.substr')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Defined in the (informative) Compatibility Annex B</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.substr', 'String.prototype.substr')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Defined in the (normative) Annex B for Additional ECMAScript Features for Web Browsers</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.substr")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.slice()")}}</li>
+ <li>{{jsxref("String.prototype.substring()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/substring/index.html b/files/pt-br/web/javascript/reference/global_objects/string/substring/index.html
new file mode 100644
index 0000000000..c54108cb75
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/substring/index.html
@@ -0,0 +1,229 @@
+---
+title: String.prototype.substring()
+slug: Web/JavaScript/Reference/Global_Objects/String/substring
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - substring()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/substring
+---
+<p>{{JSRef("Global_Objects", "String")}}</p>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O método <code>substring()</code> retorna a parte da string entre os índices inicial e final, ou até o final da string.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.substring(indexStart[, <var>indexEnd</var>])</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>indexStart</code></dt>
+ <dd>Um inteiro entre <code>0</code> e o comprimento da string (<code>str.length</code>), especificando a posição na string do primeiro caractere a ser incluído na substring retornada.</dd>
+ <dt><code>indexEnd</code></dt>
+ <dd>Opcional. Um inteiro entre <code>0</code> e o comprimento da string (<code>str.length</code>), especificando a posição na string do primeiro caractere a <strong>não</strong> ser mais incluído na substring retornada.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova string contendo a parte especificada da string fornecida.</p>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><code>substring()</code> extrai caracteres desde <code><em>indexStart</em></code> até, mas <strong>não</strong> <strong>incluindo</strong>, <code><em>indexEnd</em></code>. Em particular:</p>
+
+<ul>
+ <li>Se <code><em>indexStart</em></code> é igual a <code><em>indexEnd</em></code>, <code>substring()</code> retorna uma string vazia.</li>
+ <li>Se <code><em>indexEnd</em></code> for omitido, <code>substring()</code> extrai caracteres até o fim da string.</li>
+ <li>Se qualquer argumento for menor que <code>0</code> ou {{jsxref("NaN")}}, ele será tratado como <code>0</code>.</li>
+ <li>Se qualquer argumento for maior que <code>stringName.length</code>, ele será tratado como se fosse <code>stringName.length</code></li>
+</ul>
+
+<p>Se <code>indexStart</code> for maior que <code>indexEnd</code>, então o efeito do <code>substring()</code> é como se os dois argumentos estivessem trocados, por exemplo, <code><em>str</em>.substring(1, 0) == <em>str</em>.substring(0, 1)</code>.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example_Using_substring" name="Example:_Using_substring">Usando <code>substring()</code></h3>
+
+<p>O seguinte exemplo usa <code>substring()</code> para mostrar caracteres da palavra 'Mozilla':</p>
+
+<pre class="brush:js notranslate">var anyString = "Mozilla";
+
+// Mostra "Moz"
+console.log(anyString.substring(0,3));
+console.log(anyString.substring(3,0));
+
+// Mostra "lla"
+console.log(anyString.substring(4,7));
+console.log(anyString.substring(7,4));
+
+// Mostra "Mozill"
+console.log(anyString.substring(0,6));
+
+// Mostra "Mozilla"
+console.log(anyString.substring(0,7));
+console.log(anyString.substring(0,10));
+</pre>
+
+<h3 id="Usando_substring_com_length">Usando <code>substring()</code> com <code>length</code></h3>
+
+<p>O exemplo a seguir usa o método <code>substring()</code> e a propriedade {{jsxref ("String.length", "length")}} para extrair os últimos caracteres de uma string específica. Este método pode ser mais fácil de lembrar, visto que você não precisa saber os índices inicial e final como faria nos exemplos acima.</p>
+
+<pre class="brush: js notranslate">// Mostra 'illa', os últimos 4 caracteres
+let anyString = 'Mozilla'
+let anyString4 = anyString.substring(anyString.length - 4)
+console.log(anyString4);
+
+// Mostra 'zilla', os últimos 5 caracteres
+let anyString = 'Mozilla'
+let anyString5 = anyString.substring(anyString.length - 5)
+console.log(anyString5);</pre>
+
+<h3 id="A_diferença_entre_substring_e_substr">A diferença entre <code>substring()</code> e <code>substr()</code></h3>
+
+<p>Há uma diferença sutil entre os métodos <code>substring()</code> e {{jsxref("String.substr", "substr()")}}, então você deve ter cuidado para não confundi-los.</p>
+
+<p>Os argumentos de <code>substring()</code> representam os índices inicial e final, enquanto os argumentos de <code>substr()</code> representam o índice inicial e o número de caracteres a serem incluídos na string retornada.</p>
+
+<p>Além disso, <code>substr()</code> é considerado um <strong>recurso legacy no ECMAScript </strong>e pode ser removido em versões futuras, portanto, é melhor evitar usá-lo, se possível.</p>
+
+<pre class="brush: js notranslate">let text = 'Mozilla'
+console.log(text.substring(2,5))  // retorna "zil"
+console.log(text.substr(2,3))     // retorna "zil"</pre>
+
+<h3 id="Diferenças_entre_substring_e_slice">Diferenças entre <code>substring()</code> e <code>slice()</code></h3>
+
+<p>Os métodos <code>substring()</code> e {{jsxref("String.slice", "slice()")}} são quase idênticos, mas existem algumas diferenças sutis entre os dois, especialmente na forma como os argumentos negativos são tratados.</p>
+
+<p>O método <code>substring()</code> troca seus dois argumentos se <code>indexStart</code> for maior que <code>indexEnd</code>, o que significa que uma string ainda será retornada. O método {{jsxref("String.slice", "slice()")}} retorna uma string vazia caso o mesmo ocorra.</p>
+
+<pre class="brush: js notranslate">let text = 'Mozilla'
+console.log(text.substring(5, 2))  // retorna "zil"
+console.log(text.slice(5, 2))      // retorna ""</pre>
+
+<p>Se um ou ambos os argumentos forem negativos ou <code>NaN</code>, o método <code>substring()</code> os tratará como se fossem <code>0</code>.</p>
+
+<pre class="brush: js notranslate">console.log(text.substring(-5, 2))  // retorna "Mo"
+console.log(text.substring(-5, -2)) // retorna ""</pre>
+
+<p><code>slice()</code> também trata os argumentos <code>NaN</code> como <code>0</code>, mas quando recebe valores negativos, ele conta regressivamente a partir do final da string para encontrar os índices.</p>
+
+<pre class="brush: js notranslate">console.log(text.slice(-5, 2))   // retorna ""
+console.log(text.slice(-5, -2))  // retorna "zil"</pre>
+
+<p>Veja a página {{jsxref("String.slice", "slice()")}} para mais exemplos com números negativos.</p>
+
+<h3 id="Example_Replacing_a_substring_within_a_string" name="Example:_Replacing_a_substring_within_a_string">Substituindo uma <code>substring()</code> com uma string</h3>
+
+<p>O seguinte exemplo substitui uma substring dentro de uma string. Ela irá substituir ambos caracteres e substrings individualmente. A função invocada na linha final do exemplo altera a string "<code style="font-style: normal;">Brave New World</code>" para "<code style="font-style: normal;">Brave New Web</code>".</p>
+
+<pre class="brush:js notranslate">function replaceString(oldS, newS, fullS) {
+// Substitui oldS por newS na string fullS
+  for (var i = 0; i &lt; fullS.length; i++) {
+    if (fullS.substring(i, i + oldS.length) == oldS) {
+     fullS = fullS.substring(0, i) + newS + fullS.substring(i + oldS.length, fullS.length);
+    }
+  }
+  return fullS;
+}
+
+replaceString("World", "Web", "Brave New World");</pre>
+
+<p>Note que isto pode resultar em um loop infinito se <code>oldS</code> for um substring de <code>newS</code> -- por exemplo, se você tentou substituir "<code>World</code>" com "<code>OtherWorld</code>". O melhor método para substituir strings é o seguinte:</p>
+
+<pre class="brush:js notranslate">function replaceString(oldS, newS,fullS){
+  return fullS.split(oldS).join(newS);
+}</pre>
+
+<p>O código acima serve como um exemplo para operações com substring. Se você precisa substituir substrings, na maioria das vezes você vai querer usar <span style="line-height: 1.5em;">{{jsxref("String.prototype.replace()")}}.</span></p>
+
+<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>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Implementado no JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.15', 'String.prototype.substring')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.substring', 'String.prototype.substring')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.substr()")}}</li>
+ <li>{{jsxref("String.prototype.slice()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/sup/index.html b/files/pt-br/web/javascript/reference/global_objects/string/sup/index.html
new file mode 100644
index 0000000000..32bfbef1fd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/sup/index.html
@@ -0,0 +1,69 @@
+---
+title: String.prototype.sup()
+slug: Web/JavaScript/Reference/Global_Objects/String/sup
+tags:
+  - Descontinuado
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - sup()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/sup
+---
+<div>{{JSRef}} {{deprecated_header}}</div>
+
+<p>O método <code>sup()</code> cria um elemento HTML <code><a class="external external-icon" href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup" rel="noopener" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup">&lt;sup&gt;</a></code> que faz com que uma string seja exibida como sobrescrito.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.sup()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string contendo um elemento HTML <code><a class="external external-icon" href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup" rel="noopener" title="https://wiki.developer.mozilla.org/en-US/docs/Web/HTML/Element/sup">&lt;sup&gt;</a></code>.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>sup()</code> cria uma string dentro de uma tag <code>&lt;sup&gt;</code>: <code>"&lt;sup&gt;str&lt;/sup&gt;"</code></p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_os_métodos_sub_e_sup">Usando os métodos <code>sub()</code> e <code>sup()</code></h3>
+
+<p>O exemplo a seguir usa os métodos {{jsxref("String.prototype.sub()", "sub()")}} e <code>sup()</code> para formatar uma string:</p>
+
+<pre class="brush: js notranslate">var superText = 'superscript';
+var supText = 'supscript';
+
+console.log('This is what a ' + superText.sup() + ' looks like.');
+// "This is what a &lt;sup&gt;superscript&lt;/sup&gt; looks like."
+
+console.log('This is what a ' + supText.sup() + ' looks like.');
+// "This is what a &lt;sup&gt;supscript&lt;/sup&gt; looks like."
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.sup', 'String.prototype.sup')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.sup")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.sup()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html
new file mode 100644
index 0000000000..3867903c25
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/tolocalelowercase/index.html
@@ -0,0 +1,92 @@
+---
+title: String.prototype.toLocaleLowerCase()
+slug: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase
+tags:
+  - Internacionalização
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - toLocaleLowerCase()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleLowerCase
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>toLocaleLowerCase()</code> retorna o valor da string em minúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-tolocalelowercase.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>str</var>.toLocaleLowerCase()
+<var>str</var>.toLocaleLowerCase(locale)
+<var>str</var>.toLocaleLowerCase([locale, locale, ...])
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>locale</code></dt>
+ <dd>Opcional. O parâmetro <code>locale</code> indica o local a ser usado para converter para minúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. Se várias localidades forem fornecidas em um {{jsxref("Array")}}, a <a href="https://tc39.es/ecma402/#sec-bestavailablelocale" title="https://tc39.es/ecma402/#sec-bestavailablelocale">melhor localidade disponível</a> é usada. A localidade padrão é a localidade atual do ambiente do host.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova string que representa a string original convertida em minúsculas, de acordo com qualquer mapeamento da caixa de texto específico da localidade.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<ul>
+ <li>Um {{jsxref("RangeError")}} (" invalid language tag: xx_yy ") é lançado se um argumento <code>locale</code> não for uma tag de idioma válido.</li>
+ <li>Um {{jsxref("TypeError")}} (" invalid element in locales argument ") é lançado se um elemento do array não for do tipo string.</li>
+</ul>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>toLocaleLowerCase()</code> retorna o valor da string convertida em minúsculas de acordo com qualquer mapeamento da caixa de texto específico da localidade. <code>toLocaleLowerCase()</code> não afeta o valor da string original. Na maioria dos casos, ele produzirá o mesmo resultado que {{jsxref("String.prototype.toLowerCase()", "toLowerCase()")}}, mas para alguns locais, como turco, cujos mapeamentos da caixa de texto não seguem o mapeamento padrão em Unicode, pode haver um resultado diferente.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toLocaleLowerCase">Usando <code>toLocaleLowerCase()</code></h3>
+
+<pre class="brush: js notranslate">'ALFABETO'.toLocaleLowerCase(); // 'alfabeto'
+
+'\u0130'.toLocaleLowerCase('tr') === 'i';    // true
+'\u0130'.toLocaleLowerCase('en-US') === 'i'; // false
+
+let locales = ['tr', 'TR', 'tr-TR', 'tr-u-co-search', 'tr-x-turkish'];
+'\u0130'.toLocaleLowerCase(locales) === 'i'; // true
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocalelowercase', 'String.prototype.toLocaleLowerCase')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.toLocaleLowerCase")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
+ <li>{{jsxref("String.prototype.toLowerCase()")}}</li>
+ <li>{{jsxref("String.prototype.toUpperCase()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html
new file mode 100644
index 0000000000..ff3f99e8e3
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/tolocaleuppercase/index.html
@@ -0,0 +1,95 @@
+---
+title: String.prototype.toLocaleUpperCase()
+slug: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase
+tags:
+  - Internacionalização
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - toLocaleUpperCase()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toLocaleUpperCase
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>toLocaleUpperCase()</code> retorna o valor da string em maiúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-tolocaleuppercase.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>str</var>.toLocaleUpperCase()
+<var>str</var>.toLocaleUpperCase(locale)
+<var>str</var>.toLocaleUpperCase([locale, locale, ...])
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>locale</code></dt>
+ <dd>Opcional. O parâmetro <code>locale</code> indica a localização a ser usada para converter para maiúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. Se vários locais forem fornecidos em um {{jsxref("Array")}}, a <a href="https://tc39.es/ecma402/#sec-bestavailablelocale" title="https://tc39.es/ecma402/#sec-bestavailablelocale">melhor localidade disponível</a> é usada. A localidade padrão é a localidade atual do ambiente do host.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova string que representa a string original convertida em maiúsculas, de acordo com qualquer mapeamento de caixa de texto específico da localidade.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<ul>
+ <li>Um {{jsxref("RangeError")}} ("invalid language tag: xx_yy") é lançado se um argumento <code>locale</code> não for uma tag de idioma válido.</li>
+ <li>Um {{jsxref("TypeError")}} ("invalid element in locales argument") é lançado se um elemento do array não for do tipo string.</li>
+</ul>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>toLocaleUpperCase()</code> retorna o valor da string convertida em maiúsculas de acordo com qualquer mapeamento de caixa de texto específico da localidade. <code>toLocaleUpperCase()</code> não afeta o valor da string em si. Na maioria dos casos, ele produzirá o mesmo resultado que {{jsxref("String.prototype.toUpperCase()", "toUpperCase()")}}, mas para alguns locais, como turco, cujos mapeamentos de caixa de texto não seguem o mapeamento de caixa de texto padrão em Unicode, pode haver um resultado diferente.</p>
+
+<p>Observe também que a conversão não é necessariamente um mapeamento de caracteres 1:1, pois alguns caracteres podem resultar em dois (ou até mais) caracteres quando transformados em maiúsculas. Portanto, o comprimento da string resultante pode ser diferente do comprimento da string de entrada. Isso também implica que a conversão não é estável, então, por exemplo, o seguinte pode retornar <code>false</code>:<br>
+ <code>x.toLocaleLowerCase() === x.toLocaleUpperCase(). toLocaleLowerCase()</code></p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toLocaleUpperCase">Usando <code>toLocaleUpperCase()</code></h3>
+
+<pre class="brush: js notranslate">'alfabeto'.toLocaleUpperCase(); // 'ALFABETO'
+
+'Gesäß'.toLocaleUpperCase(); // 'GESÄSS'
+
+'i\u0307'.toLocaleUpperCase('lt-LT'); // 'I'
+
+let locales = ['lt', 'LT', 'lt-LT', 'lt-u-co-phonebk', 'lt-x-lietuva'];
+'i\u0307'.toLocaleUpperCase(locales); // 'I'</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES Int Draft', '#sup-string.prototype.tolocaleuppercase', 'String.prototype.toLocaleUpperCase')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.toLocaleUpperCase")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
+ <li>{{jsxref("String.prototype.toLowerCase()")}}</li>
+ <li>{{jsxref("String.prototype.toUpperCase()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html
new file mode 100644
index 0000000000..8883ff88fd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/tolowercase/index.html
@@ -0,0 +1,126 @@
+---
+title: String.prototype.toLowerCase()
+slug: Web/JavaScript/Reference/Global_Objects/String/toLowerCase
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - toLowerCase()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toLowerCase
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toLowerCase()</code></strong> retorna o valor da string que foi chamada convertido para minúsculo.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.toLowerCase()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova string contendo o valor da string original convertido para minúsculo.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>toLowerCase()</code> retorna o valor da string original convertido para minúsculo. <code>toLowerCase()</code> não altera o valor da string original.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toLowerCase">Usando <code>toLowerCase()</code></h3>
+
+<pre class="brush: js notranslate">console.log('ALFABETO'.toLowerCase()); // 'alfabeto'
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.16', 'String.prototype.toLowerCase')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.tolowercase', 'String.prototype.toLowerCase')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
+ <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
+ <li>{{jsxref("String.prototype.toUpperCase()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html
new file mode 100644
index 0000000000..a7f2bce0d5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/tosource/index.html
@@ -0,0 +1,102 @@
+---
+title: String.prototype.toSource()
+slug: Web/JavaScript/Reference/Global_Objects/String/toSource
+tags:
+  - JavaScript
+  - Non-standard
+  - Obsoleto
+  - Prototipo
+  - String
+  - metodo
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toSource
+---
+<div>{{JSRef}} {{obsolete_header}}</div>
+
+<p>O método <code>toSource()</code> retorna uma string que representa o código-fonte do objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>String.toSource()
+<var>str</var>.toSource()
+</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string que representa o código-fonte do objeto chamado.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Função_nativa">Função nativa</h3>
+
+<p>Para o objeto {{jsxref("String")}} , <code>toSource()</code> retorna  a seguinte string (indicando que o código-fonte não está disponível):</p>
+
+<pre class="brush: js notranslate">function String() {
+    [native code]
+}
+</pre>
+
+<p>Ao chamar {{jsxref("String")}} ou string literais, <code>toSource()</code> retorna a string que representa o código-fonte.</p>
+
+<p>Esse método é usualmente invocado internamente pelo JavaScript e não explicitamente no código.</p>
+
+<h2 id="Especificação">Especificação</h2>
+
+<p>Não é parte de nenhum padrão.</p>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html b/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html
new file mode 100644
index 0000000000..5b3a3fa1ce
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/tostring/index.html
@@ -0,0 +1,125 @@
+---
+title: String.prototype.toString()
+slug: Web/JavaScript/Reference/Global_Objects/String/toString
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - toString()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toString
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>toString()</code></strong> retorna uma string representando o objeto especificado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.toString()</code></pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O objeto {{jsxref("String")}} substitui o método <code>toString()</code> do objeto {{jsxref("Object")}}. Ele não herda {{jsxref("Object.prototype.toString()")}}. Para objetos {{jsxref("String")}}, o método <code>toString()</code> retorna uma representação de string do objeto e é o mesmo que o método {{jsxref("String.prototype.valueOf()")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_toString">Usando <code>toString()</code></h3>
+
+<p>O exemplo a seguir exibe o valor string de um objeto {{jsxref("String")}}:</p>
+
+<pre class="brush: js notranslate">var x = new String('Hello world');
+
+console.log(x.toString()); // retorna 'Hello world'
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.2', 'String.prototype.toString')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.tostring', 'String.prototype.toString')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toSource()")}}</li>
+ <li>{{jsxref("String.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html b/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html
new file mode 100644
index 0000000000..3a593fc9b8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/touppercase/index.html
@@ -0,0 +1,135 @@
+---
+title: String.prototype.toUpperCase()
+slug: Web/JavaScript/Reference/Global_Objects/String/toUpperCase
+tags:
+  - Caixa alta
+  - JavaScript
+  - Letras maúsculas
+  - Método(2)
+  - Protótipo(2)
+  - Referência(2)
+  - String
+  - toUpperCase()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/toUpperCase
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>toUpperCase()</code> retorna o valor da string original convertido em letras maiúsculas.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.toUpperCase()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova string representando a string original convertida em maiúsculas.</p>
+
+<h3 id="Exceções">Exceções</h3>
+
+<dl>
+ <dt>{{jsxref("TypeError")}}</dt>
+ <dd>Quando chamado em uma string contendo valor {{jsxref("null")}} ou {{jsxref("undefined")}}, por exemplo, <code>String.prototype.toUpperCase.call(undefined)</code>.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>toUpperCase()</code> retorna o valor da string convertido para letras maiúsculas. <code>toUpperCase()</code> não altera o valor da string original.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Uso_básico">Uso básico</h3>
+
+<pre class="brush: js notranslate">console.log('alfabeto'.toUpperCase()); // 'ALFABETO'
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.18', 'String.prototype.toUpperCase')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.touppercase', 'String.prototype.toUpperCase')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.toLocaleLowerCase()")}}</li>
+ <li>{{jsxref("String.prototype.toLocaleUpperCase()")}}</li>
+ <li>{{jsxref("String.prototype.toLowerCase()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trim/index.html b/files/pt-br/web/javascript/reference/global_objects/string/trim/index.html
new file mode 100644
index 0000000000..285cd76427
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/trim/index.html
@@ -0,0 +1,137 @@
+---
+title: String.prototype.trim()
+slug: Web/JavaScript/Reference/Global_Objects/String/Trim
+tags:
+  - ECMAScript5
+  - Prototipo
+  - Referencia
+  - Remover espaços
+  - String
+  - Texto
+  - metodo
+  - trim()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim
+---
+<div>{{JSRef}}</div>
+
+<div>O método <strong><code>trim()</code></strong> remove os espaços em branco (<a href="/pt-BR/docs/DOM/Referencia_do_DOM/Whitespace_in_the_DOM">whitespaces</a>) do início e/ou fim de um texto. É considerado espaço em branco (espaço, tabulação, espaço fixo/rígido, etc.) e todo sinal de fim de linha de texto (LF, CR, etc.).</div>
+
+<div></div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.trim()</code></pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>trim()</code> retorna o texto sem espaços em branco no início e/ou fim da string. O <code>trim()</code> não altera o valor da string original.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_trim">Usando <code>trim()</code></h3>
+
+<p>Os exemplos a seguir retornam o valor de <code>'foo'</code> sem espaços em branco:</p>
+
+<pre class="brush: js notranslate">//.trim() removendo whitespace de ambos os lados
+
+var str = '   foo  ';
+console.log(str.trim()); // retorna 'foo'
+
+// Outro exemplo de .trim() removendo whitespace de
+// apenas um lado.
+
+var str= 'foo    ';
+console.log(str.trim()); // retorna 'foo'
+</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<p>Executar o seguinte código antes antes de qualquer código irá criar o método <code>trim()</code> se o mesmo não estiver disponível nativamente.</p>
+
+<pre class="brush: js notranslate">if (!String.prototype.trim) {
+  String.prototype.trim = function () {
+    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
+  };
+}
+</pre>
+
+<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>{{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.8.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("1.9.1")}}</td>
+   <td>{{CompatIE("9")}}</td>
+   <td>{{CompatOpera("10.5")}}</td>
+   <td>{{CompatSafari("5")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li>
+ <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html b/files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html
new file mode 100644
index 0000000000..556e62d8c3
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/trimend/index.html
@@ -0,0 +1,82 @@
+---
+title: String.prototype.trimEnd()
+slug: Web/JavaScript/Reference/Global_Objects/String/trimEnd
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - Remover espaços ao final da string
+  - String
+  - metodo
+  - trimEnd()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/trimEnd
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>trimEnd()</code> remove espaços do final de uma <em>string</em>. <code>trimRight()</code> é um apelido para este método.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-trimend.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.trimEnd();
+<var>str</var>.trimRight();</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova <em>string </em>representando a <em>string</em> original sem espaços ao seu final (direita).</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Os métodos <code>trimEnd()</code> / <code>trimRight()</code> retornam a <em>string</em> sem os espaços à direita dela. <code>trimEnd()</code> ou <code>trimRight()</code> não altera o valor da <em>string</em> original.</p>
+
+<h3 id="Aliasing"><em>Aliasing</em></h3>
+
+<p>Para consistência com funções como {{jsxref("String.prototype.padEnd")}} o nome padrão do método é <code>trimEnd</code>. Entretanto, por razões de compatibilidade na <em>web</em>, <code>trimRight</code> permanece como um apelido para <code>trimEnd</code>. Em alguns motores isso significa:</p>
+
+<pre class="brush: js notranslate">String.prototype.trimRight.name === "trimEnd";</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_trimEnd">Usando <code>trimEnd()</code></h3>
+
+<p>O exemplo a seguir mostra a <em>string</em> em caixa baixa <code>'   foo'</code>:</p>
+
+<pre class="brush: js; highlight: [5] notranslate">var str = '   foo  ';
+
+console.log(str.length); // retorna 8
+
+str = str.trimEnd();
+console.log(str.length); // retorna 6
+console.log(str);        // retorna '   foo'
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.trimend', 'String.prototype.trimEnd')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.trimEnd")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.trim()")}}</li>
+ <li>{{jsxref("String.prototype.trimStart()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html b/files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html
new file mode 100644
index 0000000000..c784bc670a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/trimstart/index.html
@@ -0,0 +1,118 @@
+---
+title: String.prototype.trimStart()
+slug: Web/JavaScript/Reference/Global_Objects/String/trimStart
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - Remover espaços ao começo string
+  - String
+  - metodo
+  - trimStart()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/trimStart
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>trimStart()</code> remove espaços do começo de uma <em>string</em>. <code>trimLeft()</code> é um apelido para este método.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-trimstart.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>str</var>.trimStart();
+<var>str</var>.trimLeft();</pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova <em>string</em> representando a <em>string</em> original sem os espaços no começo (fim à esquerda).</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Os métodos <code>trimStart()</code> / <code>trimLeft()</code> retornam a <em>string</em> sem os espaços no fim à esquerda. <code>trimLeft()</code> ou <code>trimStart()</code> não altera o valor da <em>string</em> original.</p>
+
+<h3 id="Aliasing"><em>Aliasing</em></h3>
+
+<p>Para consistência com funções como {{jsxref("String.prototype.padStart")}} o nome padrão do método é <code>trimStart</code>. Entretanto, por razões de compatibilidade na <em>web</em>, <code>trimLeft</code> permanece como um apelido para <code>trimStart</code>. Em alguns motores isso significa:</p>
+
+<pre class="brush: js notranslate">String.prototype.trimLeft.name === "trimStart";</pre>
+
+<h2 id="Polyfill">Polyfill</h2>
+
+<pre class="brush: js; highlight: [5] notranslate">//https://github.com/FabioVergani/js-Polyfill_String-trimStart
+
+(function(w){
+    var String=w.String, Proto=String.prototype;
+
+    (function(o,p){
+        if(p in o?o[p]?false:true:true){
+            var r=/^\s+/;
+            o[p]=o.trimLeft||function(){
+                return this.replace(r,'')
+            }
+        }
+    })(Proto,'trimStart');
+
+})(window);
+
+
+/*
+ES6:
+(w=&gt;{
+    const String=w.String, Proto=String.prototype;
+
+    ((o,p)=&gt;{
+        if(p in o?o[p]?false:true:true){
+            const r=/^\s+/;
+            o[p]=o.trimLeft||function(){
+                return this.replace(r,'')
+            }
+        }
+    })(Proto,'trimStart');
+
+})(window);
+*/</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_trimStart">Usando <code>trimStart()</code></h3>
+
+<p>O seguinte exemplo mostra uma <em>string</em> em caixa baixa <code>'foo  '</code>:</p>
+
+<pre class="brush: js; highlight: [5] notranslate">var str = '   foo  ';
+
+console.log(str.length); // retorna 8
+
+str = str.trimStart();
+console.log(str.length); // retorna 5
+console.log(str);        // retorna 'foo  '
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.trimstart', ' String.prototype.trimStart')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.trimStart")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.trim()")}}</li>
+ <li>{{jsxref("String.prototype.trimEnd()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html b/files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html
new file mode 100644
index 0000000000..306a079a95
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/string/valueof/index.html
@@ -0,0 +1,84 @@
+---
+title: String.prototype.valueOf()
+slug: Web/JavaScript/Reference/Global_Objects/String/valueOf
+tags:
+  - JavaScript
+  - Prototipo
+  - Referencia
+  - String
+  - metodo
+  - valueOf()
+translation_of: Web/JavaScript/Reference/Global_Objects/String/valueOf
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code>valueOf()</code> retorna o valor primitivo de um objeto {{jsxref("String")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/string-valueof.html")}}</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>str</var>.valueOf()</code></pre>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma string representando o valor primitivo de um objeto {{jsxref("String")}}.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O método <code>valueOf()</code> do objeto {{jsxref("String")}} retorna o valor primitivo de um objeto {{jsxref("String")}} como um dado do tipo string. Esse valor é equivalente a {{jsxref("String.prototype.toString()")}}.</p>
+
+<p>Esse método é normalmente chamado internamente pelo JavaScript e não fica explícito no código.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_valueOf">Usando <code>valueOf()</code></h3>
+
+<pre class="brush: js notranslate">var x = new String('Olá, mundo');
+console.log(x.valueOf()); // retorna 'Olá, mundo'
+</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial implementada no JavaScript 1.1.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.5.4.3', 'String.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-string.prototype.valueof', 'String.prototype.valueOf')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Navegadores_compatíveis">Navegadores compatíveis</h2>
+
+<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+
+<p>{{Compat("javascript.builtins.String.valueOf")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.toString()")}}</li>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/asynciterator/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/asynciterator/index.html
new file mode 100644
index 0000000000..0228a1dd81
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/asynciterator/index.html
@@ -0,0 +1,75 @@
+---
+title: Symbol.asyncIterator
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/asyncIterator
+---
+<div>{{JSRef}}</div>
+
+<p>O <code><strong>Symbol.asyncIterator</strong></code> é um símbolo conhecido que especifica o padrão AsyncIterator para um objeto. Se essa propriedade é configurada em um objeto, é um iterável assíncrono e pode ser usado in um <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of">for await...of</a></code> loop.</p>
+
+
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>Symbol.asyncIterator</code> é um símbolo built-in que é usado para um acessar o método <code>@@asyncIterator</code> de um objeto. Para que um objeto seja iterável assíncrono, ele deve ter uma  chave <code>Symbol.asyncIterator</code>.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Iteráveis_assíncronos_definidos_pelo_usuário">Iteráveis assíncronos definidos pelo usuário</h3>
+
+<p>Você consegue definir seu próprio iterável assíncrono configurando a propriedade <code>[Symbol.asyncIterator]</code> em um objeto. </p>
+
+<pre class="brush: js notranslate">const myAsyncIterable = {
+    async* [Symbol.asyncIterator]() {
+        yield "hello";
+        yield "async";
+        yield "iteration!";
+    }
+};
+
+(async () =&gt; {
+    for await (const x of myAsyncIterable) {
+        console.log(x);
+        // resultado esperado:
+        //    "hello"
+        //    "async"
+        //    "iteration!"
+    }
+})();
+</pre>
+
+<p>Quando criando uma API, lembre que iteráveis assíncronos são programados para representar algum iterável — como um fluxo de dados ou uma lista —, não para substituir completamente chamadas e eventos na maioria das situações.</p>
+
+<h3 id="Iteráveis_assíncronos">Iteráveis assíncronos</h3>
+
+<p>Não há atualmente objetos Javascript built-in que tenha a chave <code>[Symbol.asyncIterator]</code> configurada por padrão. Entretanto, a WHATWG Streams estão configurando para que o primeiro objeto built-in seja um iterável assíncrono, com a recente chegada do  <code>[Symbol.asyncIterator]</code> nas especificações.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.asynciterator', 'Symbol.asyncIterator')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{compat("javascript.builtins.Symbol.asyncIterator")}}</p>
+
+<h2 id="Vejá_também">Vejá também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for-await...of">for await... of</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/description/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/description/index.html
new file mode 100644
index 0000000000..207fc79fa9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/description/index.html
@@ -0,0 +1,61 @@
+---
+title: Symbol.prototype.description
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/description
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/description
+---
+<div>{{JSRef}}</div>
+
+<p>A propriedade leitura somente <code><strong>description</strong></code> é uma string que retorna a descrição opcional de objetos {{JSxRef("Symbol")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-prototype-description.html")}}</div>
+
+
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>{{JSxRef("Symbol")}} objetos podem ser criados com uma uma descrição opcional na qual podem ser usados para debbuging mas não para acessar o próprio símbolo. A <code>Symbol.prototype.description</code> propriedade pode ser usada para ler essa descrição. É diferente do <code>Symbol.prototype.toString()</code> pois não contém a string incluida "<code>Symbol()</code>". Veja os exemplos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_descrição">Usando descrição</h3>
+
+<pre class="brush: js notranslate">Symbol('desc').toString();   // "Symbol(desc)"
+Symbol('desc').description;  // "desc"
+Symbol('').description;      // ""
+Symbol().description;        // undefined
+
+// símbolos conhecidos
+Symbol.iterator.toString();  // "Symbol(Symbol.iterator)"
+Symbol.iterator.description; // "Symbol.iterator"
+
+// símbolos globais
+Symbol.for('foo').toString();  // "Symbol(foo)"
+Symbol.for('foo').description; // "foo"
+
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName("ESDraft", "#sec-symbol.prototype.description", "get Symbol.prototype.description")}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.description")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{JSxRef("Symbol.prototype.toString()")}}</li>
+ <li>Polyfill: <a href="https://npmjs.com/symbol.prototype.description">https://npmjs.com/symbol.prototype.description</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/hasinstance/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/hasinstance/index.html
new file mode 100644
index 0000000000..b40b57a3c4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/hasinstance/index.html
@@ -0,0 +1,114 @@
+---
+title: Symbol.hasInstance
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance
+tags:
+  - Propriedade
+  - Referencia
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance
+---
+<div>{{JSRef}}</div>
+
+<p>O symbol bem-conhecido <strong><code>Symbol.hasInstance</code></strong> é usado para determinar se um objeto construtor reconhece um objeto como de sua instância. O comportamento do operador {{jsxref("Operators/instanceof", "instanceof")}} pode ser customizado por este symbol.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Você pode implementar o comportamento customizado do seu <code>instanceof</code> deste jeito; por exemplo:</p>
+
+<pre class="brush: js">class MyArray {
+  static [Symbol.hasInstance](instance) {
+    return this.prototype.isPrototypeOf(instance) ||
+           Array.isArray(instance);
+  }
+}
+
+console.log([] instanceof MyArray); // true
+console.log(new MyArray instanceof MyArray); // true
+console.log(new Image instanceof MyArray); // false
+
+class MySubArray extends MyArray {}
+console.log(new MySubArray instanceof MySubArray); // true
+console.log(new MySubArray instanceof MyArray); // true
+console.log(new MyArray instanceof MySubArray); // false</pre>
+
+<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>{{SpecName('ES6', '#sec-symbol.hasinstance', 'Symbol.hasInstance')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.hasinstance', 'Symbol.hasInstance')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(51)}}</td>
+   <td>{{ CompatGeckoDesktop(50) }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{ CompatGeckoMobile(50) }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Operators/instanceof", "instanceof")}}</li>
+ <li>{{jsxref("Global_Objects/Object/isPrototypeOf", "isPrototypeOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/index.html
new file mode 100644
index 0000000000..f4414ffe16
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/index.html
@@ -0,0 +1,301 @@
+---
+title: Símbolo
+slug: Web/JavaScript/Reference/Global_Objects/Symbol
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol
+---
+<div>{{JSRef("Global_Objects", "Symbol")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A função <code>Symbol()</code> retorna um valor do tipo <strong>símbolo (symbol)</strong>, tem propriedades estáticas que expõem vários membros dos objetos nativos, possuem métodos estáticos que expõem o registro de símbolos globais e se parecem com uma classe de objeto nativo, mas estão incompletos como construtor porque não suportam a sintaxe "<code>new Symbol()</code>" .</p>
+
+<p>Cada valor símbolo retornado de <code>Symbol()</code> é único. Um símbolo pode ser usado como o identificador para propriedades de objetos; esse é o único propósito do tipo de dado. Algumas explicações sobre propósito e uso podem ser encontradas {{Glossary("Symbol", "no verbete do glossário para Symbol")}}.</p>
+
+<p>O tipo de dado <strong>símbolo</strong> é um {{Glossary("Primitive", "tipo de dado primitivo")}}.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code>Symbol(<em>[descrição]</em>)</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parametros</h3>
+
+<dl>
+ <dt><code>descrição</code> {{optional_inline}}</dt>
+ <dd>String opcional. Uma descrição de símbolo no qual pode ser usado para debugar mas não para acessar o próprio símbolo.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Para criar um novo simbolo primitivo, simplesmente escreva <code>Symbol()</code> com uma string opçional para sua descrição:</p>
+
+<pre class="brush: js notranslate">var sym1 = Symbol();
+var sym2 = Symbol("foo");
+var sym3 = Symbol("foo");
+</pre>
+
+<p>O codigo acima cria três simbolos novos. Note que a função <strong><em>Symbol("foo")</em></strong> não faz a string <strong><em>"foo"</em></strong> ser um símbolo. Ela cria um novo simbolo a cada vez que é chamada:</p>
+
+<pre class="brush: js notranslate">Symbol("foo") === Symbol("foo"); // false</pre>
+
+<p>A sintaxe a seguir com o operador {{jsxref("Operators/new", "new")}} vai resultar em um  {{jsxref("TypeError")}}:</p>
+
+<pre class="brush: js notranslate">var sym = new Symbol(); // TypeError
+</pre>
+
+<p>Isso evita que os autores criem um objeto empacotador explícito de <code>Symbol</code> em vez de um novo valor de símbolo. O que pode surpreender, pois geralmente é possível criar objetos empacotadores explícitos em torno de tipos de dados primitivos (por exemplo, <code>new Boolean</code>, <code>new String</code> e <code>new Number</code>).</p>
+
+<p>Se você realmente quiser criar um objeto empacotador de <code>Symbol</code> , você pode usar a função <code>Object()</code>:</p>
+
+<pre class="brush: js notranslate">var sym = Symbol("foo");
+typeof sym;     // "symbol"
+var symObj = Object(sym);
+typeof symObj;  // "object"
+</pre>
+
+<h3 id="Símbolos_compartilhados_no_registro_global_de_símbolo">Símbolos compartilhados no registro global de símbolo</h3>
+
+<p>A sintaxe acima usando a função <code>Symbol()</code> não criará um símbolo global que estará disponível em todo o seu código. Para criar símbolos disponíveis em vários arquivos em um escopo como se fosse global, use os métodos {{jsxref("Symbol.for()")}} e {{jsxref("Symbol.keyFor()")}} para definir e configurar símbolos no registro global de símbolo.</p>
+
+<h3 id="Encontrando_propriedades_de_símbolos_em_objetos">Encontrando propriedades de símbolos em objetos</h3>
+
+<p>O método {{jsxref("Object.getOwnPropertySymbols()")}} retorna um array de símbolos e permite que você encontre propriedades de símbolos em um determinado objeto. Observe que cada objeto é inicializado sem suas próprias propriedades de símbolo, de modo que este array estará vazio, a menos que você estabeleça propriedades de símbolo no objeto.</p>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt><code>Symbol.length</code></dt>
+ <dd>Propriedade de tamanho cujo valor é 1.</dd>
+ <dt>{{jsxref("Symbol.prototype")}}</dt>
+ <dd>Representa o protótipo do <code>Symbol</code> construtor.</dd>
+</dl>
+
+<h3 id="Símbolos_conhecidos">Símbolos conhecidos</h3>
+
+<p>Em adição para seus próprios símbolos, JavaScript possui alguns símbolos built-in que representa os comportamentos internos da linguagem que não foram revelados para os desenvolvedores no ECMAScript 5 e anterior. Esses símbolos podem ser acessados usando as seguintes propriedades:</p>
+
+<dl>
+ <dt>Symbol.hasInstance</dt>
+ <dd>Especificado como @@hasInstance. Um método que determina se um construtor de um objeto é reconhecido como a instancia de um objeto. Usado por {{jsxref("Operators/instanceof", "instanceof")}}.</dd>
+ <dt>Symbol.isConcatSpreadable</dt>
+ <dd>Especificado como @@isConcatSpreadable. Um valor Booleano indicando se um objeto deve ser adicionado como elemento de uma array. Usado por {{jsxref("Array.prototype.concat()")}}.</dd>
+ <dt>Symbol.isRegExp</dt>
+ <dd>Especificado como @@isRegExp. Um valor Booleano indicando se um objeto pode ser usado como uma expressão regular.</dd>
+ <dt>Symbol.iterator</dt>
+ <dd>Especificado como @@iterator. Um método retornando o iterador padrão para um objeto. Usado por <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>.</dd>
+ <dt>Symbol.toPrimitive</dt>
+ <dd>Especificado como @@toPrimitive. Um método convertendo um objeto para um valor primitivo .</dd>
+ <dt>Symbol.toStringTag</dt>
+ <dd>Especificado como @@toStringTag. Um valor string usado para descrição padrão de um objeto. Usado por {{jsxref("Object.prototype.toString()")}}</dd>
+ <dt>Symbol.unscopables</dt>
+ <dd>Especificado como @@unscopables. Uma Array com valores string que são  valores propriedade. Esses são excluídos das ligações com o objeto associado.</dd>
+</dl>
+
+<h2 id="Methods" name="Methods">Métodos</h2>
+
+<dl>
+ <dt>{{jsxref("Symbol.for()", "Symbol.for(key)")}}</dt>
+ <dd>Procura por símbolos existentes com as chaves dada e retorna as chaves se for encontradas. Caso contrário um novo símbolo vai ser criado no registro de símbolo global com essa chave.</dd>
+ <dt>{{jsxref("Symbol.keyFor", "Symbol.keyFor(sym)")}}</dt>
+ <dd>Retorna um símbolo compartilhado do registro global de símbolo para o símbolo dado.</dd>
+</dl>
+
+<h2 id="Boolean_instances" name="Boolean_instances"><code>Symbol</code> protótipo</h2>
+
+<p>Todos os símbolos herdados de {{jsxref("Symbol.prototype")}}.</p>
+
+<h3 id="Propriedades">Propriedades</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Properties')}}</p>
+
+<h3 id="Métodos">Métodos</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Methods')}}</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Creating_Boolean_objects_with_an_initial_value_of_false" name="Creating_Boolean_objects_with_an_initial_value_of_false">Usando o <code>typeof</code> operador com símbolos</h3>
+
+<p>O {{jsxref("Operators/typeof", "typeof")}} operador pode ajudar a identificar os símbolos.</p>
+
+<pre class="brush: js notranslate">typeof Symbol() === 'symbol'
+typeof Symbol('foo') === 'symbol'
+typeof Symbol.iterator === 'symbol'
+</pre>
+
+<h3 id="Conversões_de_tipos_de_símbolo">Conversões de tipos de símbolo</h3>
+
+<p>Algumas anotações quando trabalhando com conversão de tipo de símbolos.</p>
+
+<ul>
+ <li>Quando estiver tentando converter um símbolo para um número, um {{jsxref("TypeError")}} vai ser retornado.<br>
+  (e.g. <code>+sym</code> or <code>sym | 0</code>).</li>
+ <li>Quando usando operador de igualdade , <code>Object(sym) == sym</code> retorna <code>true.</code></li>
+ <li><code>Symbol("foo") + "bar" </code>lança um {{jsxref("TypeError")}} (não pode converter um símbolo para string). Isso previne você de silenciamente criar um novo nome de propriedade string a partir de um símbolo, por exemplo.</li>
+ <li>A <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#String_conversion">"safer" <code>String(sym)</code> conversion</a> funciona como uma chamada para {{jsxref("Symbol.prototype.toString()")}} com símbolos, mas note que uma <code>new String(sym)</code> vai ser lançada.</li>
+</ul>
+
+<h3 id="Símbolos_e_for...in_iteração">Símbolos e <code>for...in</code> iteração</h3>
+
+<p>Símbolos não são visíveis em <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a> iterações. Além de , {{jsxref("Object.getOwnPropertyNames()")}} não retornará o objeto símbolo propriedade, entretante, você pode fazer uso do {{jsxref("Object.getOwnPropertySymbols()")}} para conseguir esses resultados.</p>
+
+<pre class="brush: js notranslate">var obj = {};
+
+obj[Symbol("a")] = "a";
+obj[Symbol.for("b")] = "b";
+obj["c"] = "c";
+obj.d = "d";
+
+for (var i in obj) {
+   console.log(i); // logs "c" and "d"
+}</pre>
+
+<h3 id="Símbolos_e_JSON.stringify">Símbolos e <code>JSON.stringify()</code></h3>
+
+<p>Propriedade com chave de símbolo vão ser completamente ignoradas quando usando <code>JSON.stringify()</code>:</p>
+
+<pre class="brush: js notranslate">JSON.stringify({[Symbol("foo")]: "foo"});
+// '{}'</pre>
+
+<p>Para mais detalhes, veja {{jsxref("JSON.stringify()")}}.</p>
+
+<h3 id="Objeto_wrapper_de_símbolo_como_chave_de_propriedade">Objeto wrapper de símbolo como chave de propriedade</h3>
+
+<p>Quando um objeto wrapper de um símbolo é usado como uma chave de propriedade , esse objeto vai ser coerced para o seu símbolo wrapper:</p>
+
+<pre class="brush: js notranslate">var sym = Symbol("foo");
+var obj = {[sym]: 1};
+obj[sym];            // 1
+obj[Object(sym)];    // still 1
+</pre>
+
+<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>{{SpecName('ES2015', '#sec-symbol-objects', 'Symbol')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(38)}}</td>
+   <td>{{CompatGeckoDesktop("36.0")}}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>25</td>
+   <td>{{ CompatNo() }}</td>
+  </tr>
+  <tr>
+   <td>Symbol.iterator (@@iterator)</td>
+   <td>{{CompatChrome(38)}}</td>
+   <td>{{CompatGeckoDesktop("36.0")}}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>25</td>
+   <td>{{ CompatNo() }}</td>
+  </tr>
+  <tr>
+   <td>Symbol.unscopables (@@unscopables)</td>
+   <td>{{CompatChrome(38)}}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>25</td>
+   <td>
+    <div>{{ CompatNo() }}</div>
+   </td>
+  </tr>
+  <tr>
+   <td>Other well-known symbols</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{CompatChrome(38)}}</td>
+   <td>{{ CompatGeckoMobile("36.0") }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>25</td>
+   <td>{{ CompatNo() }}</td>
+  </tr>
+  <tr>
+   <td>Symbol.iterator (@@iterator)</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{CompatChrome(38)}}</td>
+   <td>{{ CompatGeckoMobile("36.0") }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>25</td>
+   <td>{{ CompatNo() }}</td>
+  </tr>
+  <tr>
+   <td>
+    <div>Symbol.unscopables (@@unscopables)</div>
+   </td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{CompatChrome(38)}}</td>
+   <td>{{ CompatUnknown() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>25</td>
+   <td>{{ CompatNo() }}</td>
+  </tr>
+  <tr>
+   <td>Other well-known symbols</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Glossary/Symbol">Glossary: Symbol data type</a></li>
+ <li>{{jsxref("Operators/typeof", "typeof")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Data_structures">Data types and data structures</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/isconcatspreadable/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/isconcatspreadable/index.html
new file mode 100644
index 0000000000..f969972692
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/isconcatspreadable/index.html
@@ -0,0 +1,93 @@
+---
+title: Symbol.isConcatSpreadable
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/isConcatSpreadable
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/isConcatSpreadable
+---
+<div>{{JSRef}}</div>
+
+<p>O <strong><code>Symbol.isConcatSpreadable</code></strong> é um símbolo conhecido que é usado para configurar se um objeto deve ser achatado para um elemento da array quando usado o método {{jsxref("Array.prototype.concat()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-isconcatspreadable.html")}}</div>
+
+
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>@@isConcatSpreadable</code> símbolo (<code>Symbol.isConcatSpreadable</code>) pode também ser definido como uma propriedade própria ou herdada e seu valor é um booleano. Ele consegue controlar o comportamento das arrays e objetos semelhantes a array:</p>
+
+<ul>
+ <li>For array objects, the default behavior is to spread (flatten) elements. <code>Symbol.isConcatSpreadable</code> can avoid flattening in these cases.</li>
+ <li>For array-like objects, the default behavior is no spreading or flattening. <code>Symbol.isConcatSpreadable</code> can force flattening in these cases.</li>
+</ul>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Arrays">Arrays</h3>
+
+<p>Por padrão, o {{jsxref("Array.prototype.concat()")}} espalha (alinha) arrays no seus resultados:</p>
+
+<pre class="brush: js notranslate">let alpha = ['a', 'b', 'c'],
+let numeric = [1, 2, 3]
+
+let alphaNumeric = alpha.concat(numeric)
+
+console.log(alphaNumeric)  // Resultado: ['a', 'b', 'c', 1, 2, 3]
+</pre>
+
+<p>Quando configurando o <code>Symbol.isConcatSpreadable</code> para <code>false</code>, o comportamento padrão dele:</p>
+
+<pre class="brush: js notranslate">let alpha = ['a', 'b', 'c'],
+let numeric = [1, 2, 3]
+
+numeric[Symbol.isConcatSpreadable] = false
+let alphaNumeric = alpha.concat(numeric)
+
+console.log(alphaNumeric)  // Resultado: ['a', 'b', 'c', [1, 2, 3] ]
+</pre>
+
+<h3 id="Objetos_de_array_semelhantes">Objetos de array semelhantes </h3>
+
+<p>Para objetos de array semelhantes, o padrão não é espalhado. <code>Symbol.isConcatSpreadable</code>precisa ser configurado para <code>true</code> para poder conseguir um a array alinhada:</p>
+
+<pre class="brush: js notranslate">let x = [1, 2, 3]
+
+let fakeArray = {
+  [Symbol.isConcatSpreadable]: true,
+  length: 2,
+  0: 'hello',
+  1: 'world'
+}
+
+x.concat(fakeArray)  // [1, 2, 3, "hello", "world"]
+</pre>
+
+<div class="blockIndicator note">
+<p><strong>Note:</strong> A propriedade <code>length</code> é usada para controlar o número de propriedade dos objetos para ser adicionado. No exemplo acima, <code>length:2</code> indica que duas propriedades tem de ser adicionado.</p>
+</div>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.isconcatspreadable', 'Symbol.isconcatspreadable')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.isConcatSpreadable")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.concat()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/iterator/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/iterator/index.html
new file mode 100644
index 0000000000..99e910ce5b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/iterator/index.html
@@ -0,0 +1,107 @@
+---
+title: Symbol.iterator
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/iterator
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/iterator
+---
+<div>{{JSRef}}</div>
+
+<p>O símbolo conhecido <code><strong>Symbol.iterator</strong></code> especifíca o iterador padrão para um objeto. Usado por <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-iterator.html")}}</div>
+
+
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Sempre que um objeto precisa ser iterado (como um começo de um <code>for..of</code> loop), o método <code>@@iterator</code> é chamado sem argumentos, e o <strong>iterador</strong> retornado é usado para obter os valores para serem iterados.</p>
+
+<p>Alguns tipos built-in tem um comportamento padrão de iteração, enquanto outros tipos (assim como {{jsxref("Object")}}) não tem. O tipo built-in com um método <code>@@iterator</code> são:</p>
+
+<ul>
+ <li>{{jsxref("Array.@@iterator", "Array.prototype[@@iterator]()")}}</li>
+ <li>{{jsxref("TypedArray.@@iterator", "TypedArray.prototype[@@iterator]()")}}</li>
+ <li>{{jsxref("String.@@iterator", "String.prototype[@@iterator]()")}}</li>
+ <li>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</li>
+ <li>{{jsxref("Set.@@iterator", "Set.prototype[@@iterator]()")}}</li>
+</ul>
+
+<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a> para mais informação.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Iteráveis_​​definidos_pelo_usuário">Iteráveis ​​definidos pelo usuário</h3>
+
+<p>Podemos fazer nosso próprio iterável dessa forma:</p>
+
+<pre class="brush: js notranslate">var myIterable = {}
+myIterable[Symbol.iterator] = function* () {
+    yield 1;
+    yield 2;
+    yield 3;
+};
+[...myIterable] // [1, 2, 3]
+</pre>
+
+<p>Ou iteráveis podem ser definidos diretamente dentro de uma classe ou um objeto usando  <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names">computed property</a>:</p>
+
+<pre class="brush: js notranslate">class Foo {
+  *[Symbol.iterator] () {
+    yield 1;
+    yield 2;
+    yield 3;
+  }
+}
+
+const someObj = {
+  *[Symbol.iterator] () {
+    yield 'a';
+    yield 'b';
+  }
+}
+
+[...new Foo] // [ 1, 2, 3 ]
+[...someObj] // [ 'a', 'b' ]
+</pre>
+
+<h3 id="Iteráveis_​​não_bem_formados">Iteráveis ​​não bem formados</h3>
+
+<p>Se um método <code>@@iterator</code> não retornar um objeto iterador, então é um iterável não bem formado. Usando dessa forma é resultará em uma excessão de tempo ou comportamentos com erros:</p>
+
+<pre class="brush: js notranslate">var nonWellFormedIterable = {}
+nonWellFormedIterable[Symbol.iterator] = () =&gt; 1
+[...nonWellFormedIterable] // TypeError: [] is not a function
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.iterator', 'Symbol.iterator')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.iterator")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols">Iteration protocols</a></li>
+ <li>{{jsxref("Array.@@iterator", "Array.prototype[@@iterator]()")}}</li>
+ <li>{{jsxref("TypedArray.@@iterator", "TypedArray.prototype[@@iterator]()")}}</li>
+ <li>{{jsxref("String.@@iterator", "String.prototype[@@iterator]()")}}</li>
+ <li>{{jsxref("Map.@@iterator", "Map.prototype[@@iterator]()")}}</li>
+ <li>{{jsxref("Set.@@iterator", "Set.prototype[@@iterator]()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/match/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/match/index.html
new file mode 100644
index 0000000000..34773830af
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/match/index.html
@@ -0,0 +1,65 @@
+---
+title: Symbol.match
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/match
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/match
+---
+<div>{{JSRef}}</div>
+
+<p>O símbolo <code><strong>Symbol.match</strong></code> é conhecido por especificar a compatibilidade de uam expressão regular contra uma string. Essa função é chamada pelo método {{jsxref("String.prototype.match()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-match.html")}}</div>
+
+
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Essa função também é usada para identificar se um objeto tem o comportamento de uma expressão regular. Por exemplo, os métodos {{jsxref("String.prototype.startsWith()")}}, {{jsxref("String.prototype.endsWith()")}} e {{jsxref("String.prototype.includes()")}}, verificar se o primeiro agumento é uma expressão regular e  irá lançar um {{jsxref("TypeError")}} se eles forém. Agora, se o símbolo <code>match</code> é configurado para <code>false</code> (ou um valor <a href="/en-US/docs/Glossary/Falsy">Falsy</a> ), ele indica que o objeto não tem intensão de ser usado como um ojbeto de  expressão regular </p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Desativando_a_verificação_isRegExp">Desativando a verificação <code>isRegExp</code> </h3>
+
+<p>O seguinte código vai lançar um {{jsxref("TypeError")}}:</p>
+
+<pre class="brush: js notranslate">'/bar/'.startsWith(/bar/);
+
+// Lança um TypeError, como /bar/ é uma expressão regular
+// não Symbol.match não é modificado.</pre>
+
+<p>Entretanto, se você configurar <code>Symbol.match</code> para <code>false</code>, a verificação <code>isRegExp </code>(que usa a propriedade <code>match</code> ) que o objeto não é uma expressão regular. O método <code>startsWith</code> e <code>endsWith</code> não vão lançar um <code>TypeError</code> como consequência.</p>
+
+<pre class="brush: js notranslate">var re = /foo/;
+re[Symbol.match] = false;
+'/foo/'.startsWith(re); // true
+'/baz/'.endsWith(re);   // false
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.match', 'Symbol.match')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.match")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Symbol.replace")}}</li>
+ <li>{{jsxref("Symbol.search")}}</li>
+ <li>{{jsxref("Symbol.split")}}</li>
+ <li>{{jsxref("RegExp.@@match", "RegExp.prototype[@@match]()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/matchall/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/matchall/index.html
new file mode 100644
index 0000000000..7874646623
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/matchall/index.html
@@ -0,0 +1,72 @@
+---
+title: Symbol.matchAll
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/matchAll
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/matchAll
+---
+<div>{{JSRef}}</div>
+
+<p>O símbolo <code><strong>Symbol.matchAll</strong></code> é conhecido por retornar um iterador, que produz conrrespondências de uma expressão regular com uma string. Essa função é usada pelo método {{jsxref("String.prototype.matchAll()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-matchall.html","shorter")}}</div>
+
+
+
+<h2 id="Descrição">Descrição</h2>
+
+<div>
+<p>Esse símbolo é usado pelo {{jsxref("String.prototype.matchAll()")}} e especificado no {{jsxref("RegExp.@@matchAll", "RegExp.prototype[@@matchAll]()")}}. Os próximos dois exemplos retornam o mesmo resultado:</p>
+
+<pre class="brush: js notranslate">'abc'.matchAll(/a/);
+
+/a/[Symbol.matchAll]('abc');</pre>
+
+<p>Esse método existe para costumizar o comportamento conrrespondente com as subclasses {{jsxref("RegExp")}}.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usuando_Symbol.matchAll">Usuando Symbol.matchAll</h3>
+
+<pre class="brush: js notranslate">let re = /[0-9]+/g;
+let str = '2016-01-02|2019-03-07';
+
+const numbers = {
+  *[Symbol.matchAll] (str) {
+    for (const n of str.matchAll(/[0-9]+/g))
+      yield n[0];
+  }
+};
+
+console.log(Array.from(str.matchAll(numbers)));
+//  Array ["2016", "01", "02", "2019", "03", "07"]
+</pre>
+
+<p>Veja {{jsxref("String.prototype.matchAll()")}} e {{jsxref("RegExp.@@matchAll", "RegExp.prototype[@@matchAll]()")}} para mais exemplos.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.matchall', 'Symbol.matchAll')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.matchAll")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String.prototype.matchAll()")}}</li>
+ <li>{{jsxref("RegExp.@@matchAll", "RegExp.prototype[@@matchAll]()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/replace/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/replace/index.html
new file mode 100644
index 0000000000..f69a22537d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/replace/index.html
@@ -0,0 +1,60 @@
+---
+title: Symbol.replace
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/replace
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/replace
+---
+<div>{{JSRef}}</div>
+
+<p>O símbolo <code><strong>Symbol.replace</strong></code> é conhecido por especificar o método que substitui as substrings conrrespondentes de uma string. Essa função é chamada pelo método {{jsxref("String.prototype.replace()")}}.</p>
+
+<p>Para mais informações, veja {{jsxref("RegExp.@@replace", "RegExp.prototype[@@replace]()")}} e {{jsxref("String.prototype.replace()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-replace.html")}}</div>
+
+
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_Symbol.replace">Usando Symbol.replace</h3>
+
+<pre class="brush: js notranslate">class CustomReplacer {
+  constructor(value) {
+    this.value = value;
+  }
+  [Symbol.replace](string) {
+    return string.replace(this.value, '#!@?');
+  }
+}
+
+console.log('football'.replace(new CustomReplacer('foo')));
+// resultado esperado: "#!@?tball"</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.replace', 'Symbol.replace')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.replace")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Symbol.match")}}</li>
+ <li>{{jsxref("Symbol.search")}}</li>
+ <li>{{jsxref("Symbol.split")}}</li>
+ <li>{{jsxref("RegExp.@@replace", "RegExp.prototype[@@replace]()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/search/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/search/index.html
new file mode 100644
index 0000000000..e2f71e3438
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/search/index.html
@@ -0,0 +1,60 @@
+---
+title: Symbol.search
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/search
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/search
+---
+<div>{{JSRef}}</div>
+
+<p>O símbolo <code><strong>Symbol.search</strong></code> é um método conhecido por retornar o índice com uma string que corresponde a expressão regular. Essa função é chamada pelo método {{jsxref("String.prototype.search()")}}.</p>
+
+<p>Para mais informação, veja {{jsxref("RegExp.@@search", "RegExp.prototype[@@search]()")}} e {{jsxref("String.prototype.search()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-search.html")}}</div>
+
+
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Pesquisa_de_string_personalizada">Pesquisa de string personalizada</h3>
+
+<pre class="brush: js notranslate">class caseInsensitiveSearch {
+  constructor(value) {
+    this.value = value.toLowerCase();
+  }
+  [Symbol.search](string) {
+    return string.toLowerCase().indexOf(this.value);
+  }
+}
+
+console.log('foobar'.search(new caseInsensitiveSearch('BaR')));
+// resultado esperado: 3</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.search', 'Symbol.search')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.search")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Symbol.match")}}</li>
+ <li>{{jsxref("Symbol.replace")}}</li>
+ <li>{{jsxref("Symbol.split")}}</li>
+ <li>{{jsxref("RegExp.@@search", "RegExp.prototype[@@search]()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/species/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/species/index.html
new file mode 100644
index 0000000000..fcf636c175
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/species/index.html
@@ -0,0 +1,63 @@
+---
+title: Symbol.species
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/species
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/species
+---
+<div>{{JSRef}}</div>
+
+<p>O símbolo <code><strong>Symbol.species</strong></code> especifica uma propriedade valor-função que a função construtora usa para criar objetos derivados.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-species.html")}}</div>
+
+
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A propriedade acessora de espécies permite que subclasses substituam o construtor padrão para objetos.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_espécies">Usando espécies</h3>
+
+<p>Você pode querer que retorne objetos {{jsxref("Array")}} em sua class derivada de array <code>MyArray</code>. Por exemplo, quando usar métodos tais como {{jsxref("Array.map", "map()")}} que retorna o construtor padrão, você quer que esses métodos retornem um objeto  <code>Array</code> pai, em vez do objeto <code>MyArray</code>. Esses símbolos espécies permitem que você fala isso:</p>
+
+<pre class="brush: js notranslate">class MyArray extends Array {
+  // Substitui espécies para a Array pai construtora
+  static get [Symbol.species]() { return Array; }
+}
+let a = new MyArray(1,2,3);
+let mapped = a.map(x =&gt; x * x);
+
+console.log(mapped instanceof MyArray); // false
+console.log(mapped instanceof Array);   // true
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.species', 'Symbol.species')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.species")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map.@@species", "Map[@@species]")}}</li>
+ <li>{{jsxref("Set.@@species", "Set[@@species]")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/split/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/split/index.html
new file mode 100644
index 0000000000..c6b9e13fd3
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/split/index.html
@@ -0,0 +1,60 @@
+---
+title: Symbol.split
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/split
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/split
+---
+<div>{{JSRef}}</div>
+
+<p>O <code><strong>Symbol.split</strong></code> é um símbolo conhecido que especifica o método que divide uma string nos índices correspondentes a uma expressão regular. Essa função é chamada pelo método {{jsxref("String.prototype.split()")}}.</p>
+
+<p>Para mais informações, veja {{jsxref("RegExp.@@split", "RegExp.prototype[@@split]()")}} e {{jsxref("String.prototype.split()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-split.html")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Divisão_reversa_personalizada">Divisão reversa personalizada</h3>
+
+<pre class="brush: js notranslate">class ReverseSplit {
+  [Symbol.split](string) {
+    const array = string.split(' ');
+    return array.reverse();
+  }
+}
+
+console.log('Another one bites the dust'.split(new ReverseSplit()));
+// resultado esperado: [ "dust", "the", "bites", "one", "Another" ]</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.split', 'Symbol.split')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.split")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Symbol.match")}}</li>
+ <li>{{jsxref("Symbol.replace")}}</li>
+ <li>{{jsxref("Symbol.search")}}</li>
+ <li>{{jsxref("RegExp.@@split", "RegExp.prototype[@@split]()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/toprimitive/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/toprimitive/index.html
new file mode 100644
index 0000000000..97734f23e2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/toprimitive/index.html
@@ -0,0 +1,75 @@
+---
+title: Symbol.toPrimitive
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/toPrimitive
+---
+<div>{{JSRef}}</div>
+
+<p>O <code><strong>Symbol.toPrimitive</strong></code> é um símbolo que específica uma propriedade com valor função que é chamada para converter um ojbeto para um valor primitivo correspondente. </p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-toprimitive.html")}}</div>
+
+
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Com a ajuda da propriedade <strong><code>Symbol.toPrimitive</code></strong> (usada como uma função valor), um objeto pode ser convertido para um valor primitivo. a função é chamada com um argumento string <strong><code>hint</code></strong>, que espcífica o tipo de preferência do resultado do valor primitivo. O argumento <strong><code>hint</code></strong> pode ser um <code>"<em>number</em>"</code>, <code>"<em>string</em>"</code>, e <code>"<em>default</em>"</code>.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Modificando_valores_primitivos_convertendo_para_um_objeto">Modificando valores primitivos convertendo para um objeto</h3>
+
+<p>O exemplo a seguir descreve que a propriedade <strong><code>Symbol.toPrimitive</code></strong> pode ser modificar o valor primitivo convertendo para um objeto.</p>
+
+<pre class="brush: js notranslate">// Um objeto sem propriedade Symbol.toPrimitive.
+var obj1 = {};
+console.log(+obj1);     // NaN
+console.log(`${obj1}`); // "[object Object]"
+console.log(obj1 + ''); // "[object Object]"
+
+// Um objeto com propriedade Symbol.toPrimitive
+var obj2 = {
+  [Symbol.toPrimitive](hint) {
+    if (hint == 'number') {
+      return 10;
+    }
+    if (hint == 'string') {
+      return 'hello';
+    }
+    return true;
+  }
+};
+console.log(+obj2);     // 10        -- dica é "number"
+console.log(`${obj2}`); // "hello"   -- dica é "string"
+console.log(obj2 + ''); // "true"    -- dica é "default"
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.toprimitive', 'Symbol.toPrimitive')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.toPrimitive")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Date.@@toPrimitive", "Date.prototype[@@toPrimitive]")}}</li>
+ <li>{{jsxref("Symbol.@@toPrimitive", "Symbol.prototype[@@toPrimitive]")}}</li>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+ <li>{{jsxref("Object.prototype.valueOf()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/tostringtag/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/tostringtag/index.html
new file mode 100644
index 0000000000..1418ff89c0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/tostringtag/index.html
@@ -0,0 +1,92 @@
+---
+title: Symbol.toStringTag
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/toStringTag
+---
+<div>{{JSRef}}</div>
+
+<p>O símbolo <strong><code>Symbol.toStringTag</code></strong> é uma propriedade com valor string que é usada para a criação de uma descrição de string de um objeto padrão. É acessado internalmente pelo método {{jsxref("Object.prototype.toString()")}}.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-tostringtag.html")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Tags_padrões">Tags padrões</h3>
+
+<pre class="brush: js notranslate">Object.prototype.toString.call('foo');     // "[object String]"
+Object.prototype.toString.call([1, 2]);    // "[object Array]"
+Object.prototype.toString.call(3);         // "[object Number]"
+Object.prototype.toString.call(true);      // "[object Boolean]"
+Object.prototype.toString.call(undefined); // "[object Undefined]"
+Object.prototype.toString.call(null);      // "[object Null]"
+// ... e mais
+</pre>
+
+<h3 id="Símbolos_built-in_toStringTag">Símbolos built-in toStringTag </h3>
+
+<pre class="brush: js notranslate">Object.prototype.toString.call(new Map());       // "[object Map]"
+Object.prototype.toString.call(function* () {}); // "[object GeneratorFunction]"
+Object.prototype.toString.call(Promise.resolve()); // "[object Promise]"
+// ... e mais
+</pre>
+
+<h3 id="Classes_personalizadas_para_objeto_tag">Classes personalizadas para objeto tag</h3>
+
+<p>Quando cria sua própria classe, o JavaScript padroniza para "Object" tag:</p>
+
+<pre class="brush: js notranslate">class ValidatorClass {}
+
+Object.prototype.toString.call(new ValidatorClass()); // "[object Object]"
+</pre>
+
+<h3 id="Tag_costumizada_com_toStringTag">Tag costumizada com toStringTag</h3>
+
+<p>Agora, com a ajuda do <code>toStringTag</code>, você é capaz de costumizar sua própria tag:</p>
+
+<pre class="brush: js notranslate">class ValidatorClass {
+  get [Symbol.toStringTag]() {
+    return 'Validator';
+  }
+}
+
+Object.prototype.toString.call(new ValidatorClass()); // "[object Validator]"
+</pre>
+
+<h3 id="toStringTag_disponível_em_todos_os_objetos_protótipos_da_DOM">toStringTag disponível em todos os objetos protótipos da DOM </h3>
+
+<p>Devido a uma mudança nas especificações <a href="https://github.com/heycam/webidl/pull/357">WebIDL spec change</a> em meados de 2020, navegadores estão adicionando uma propriedade <code>Symbol.toStringTag</code> para todos os objetos protótipos da DOM . Por exemplo, para acessar a propriedade <code>Symbol.toStringTag</code> no {{domxref("HTMLButtonElement")}}:</p>
+
+<pre class="brush: js notranslate">let test = document.createElement('button');
+test.toString(); // Retorna [object HTMLButtonElement]
+test[Symbol.toStringTag];  // Retona HTMLButtonElement</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.tostringtag', 'Symbol.toStringTag')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.toStringTag")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object.prototype.toString()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/symbol/unscopables/index.html b/files/pt-br/web/javascript/reference/global_objects/symbol/unscopables/index.html
new file mode 100644
index 0000000000..f1f76c2177
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/symbol/unscopables/index.html
@@ -0,0 +1,83 @@
+---
+title: Symbol.unscopables
+slug: Web/JavaScript/Reference/Global_Objects/Symbol/unscopables
+translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/unscopables
+---
+<div>{{JSRef}}</div>
+
+<p>O símbolo <strong><code>Symbol.unscopables</code></strong> é usado para específicar um valor objeto cujo os nomes de propriedade próprio e herdados são excluídos das associações do ambiente <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> o objeto associado. </p>
+
+<div>{{EmbedInteractiveExample("pages/js/symbol-unscopables.html")}}</div>
+
+
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>@@unscopables</code> símbolo (<code>Symbol.unscopables</code>) pode ser definido em qualquer objeto para impedir que os nomes da propriedade sejam expostos como variavéis lexicais <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> ligações de ambiente. Note que se usar o  <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">Strict mode</a>, <code>with</code> as declarações não estão disponíveis e provavelmente não haverá necessidade desse símbolo.</p>
+
+<p>Configurando a propriedade para <code>true</code> em um objeto <code>unscopables</code> tornará ele não <em>unscopable</em> e portanto não irá apareer nas variavéis de escopo lexicais. Configurando uma propriedade para <code>false</code> o tornará <code>scopable</code> e portanto irá aparecer no escopo de variavéis lexicais.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Escopo_com_declarações">Escopo com declarações</h3>
+
+<p>O seguinte código funciona normalmente no ES5 e anteriores. Entretanto, no ECMAScript 2015 e superiores, o método {{jsxref("Array.prototype.keys()")}} foi introduzido. Isso significa que dentro do ambiente <code>with</code>  "chaves" seria agora o método e não as variavéis. Isso qunado os símbolos <code>unscopable</code>s foram introduzidos. Uma confiração built-in <code>unscopables</code> é implementada como {{jsxref("Array.@@unscopables", "Array.prototype[@@unscopables]")}} para prevenir que alguns métodos de Array tenham escopo definido na desclaração <code>with</code>.</p>
+
+<pre class="brush: js notranslate">var keys = [];
+
+with (Array.prototype) {
+  keys.push('something');
+}
+
+Object.keys(Array.prototype[Symbol.unscopables]);
+// ["copyWithin", "entries", "fill", "find", "findIndex",
+//  "includes", "keys", "values"]
+</pre>
+
+<h3 id="Objetos_não_escopáveis">Objetos não escopáveis</h3>
+
+<p>Você também pode configurar <code>unscopables</code> para seu próprio objeot.</p>
+
+<pre class="brush: js notranslate">var obj = {
+  foo: 1,
+  bar: 2
+};
+
+obj[Symbol.unscopables] = {
+  foo: false,
+  bar: true
+};
+
+with (obj) {
+  console.log(foo); // 1
+  console.log(bar); // ReferenceError: bar is not defined
+}
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-symbol.unscopables', 'Symbol.unscopables')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.Symbol.unscopables")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Array.@@unscopables", "Array.prototype[@@unscopables]")}}</li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> statement (not available in <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">Strict mode</a>)</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/typedarray/index.html b/files/pt-br/web/javascript/reference/global_objects/typedarray/index.html
new file mode 100644
index 0000000000..9d34da5245
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/typedarray/index.html
@@ -0,0 +1,364 @@
+---
+title: TypedArray
+slug: Web/JavaScript/Reference/Global_Objects/TypedArray
+tags:
+  - JavaScript
+  - NeedsTranslation
+  - TopicStub
+  - TypedArray
+  - TypedArrays
+translation_of: Web/JavaScript/Reference/Global_Objects/TypedArray
+---
+<div>{{JSRef}}</div>
+
+<p>A <strong><em>TypedArray</em></strong> object describes an array-like view of an underlying <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer">binary data buffer</a>. There is no global property named <code>TypedArray</code>, nor is there a directly visible <code>TypedArray</code> constructor.  Instead, there are a number of different global properties, whose values are typed array constructors for specific element types, listed below. On the following pages you will find common properties and methods that can be used with any typed array containing elements of any type.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">new<em> TypedArray</em>(length);
+new <em>TypedArray</em>(typedArray);
+new <em>TypedArray</em>(object);
+new <em>TypedArray</em>(buffer [, byteOffset [, length]]);
+
+where <em>TypedArray()</em> is one of:
+
+Int8Array();
+Uint8Array();
+Uint8ClampedArray();
+Int16Array();
+Uint16Array();
+Int32Array();
+Uint32Array();
+Float32Array();
+Float64Array();
+</pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt>length</dt>
+ <dd>When called with a <code>length</code> argument, an internal array buffer is created in memory of size <em>length multiplied by BYTES_PER_ELEMENT</em> bytes containing 0 value.</dd>
+ <dt>typedArray</dt>
+ <dd>When called with a <code>typedArray</code> argument, which can be an object of any of the typed array types (such as <code>Int32Array</code>), the <code>typedArray</code> gets copied into a new typed array. Each value in <code>typedArray</code> is converted to the corresponding type of the constructor before being copied into the new array. Then length of the new typedArray object will be same of length of the typedArray argument.</dd>
+ <dt>object</dt>
+ <dd>When called with an <code>object</code> argument, a new typed array is created as if by the <code><em>TypedArray</em>.from()</code> method.</dd>
+ <dt>buffer, byteOffset, length</dt>
+ <dd>When called with a <code>buffer</code>, and optionally a <code>byteOffset</code> and a <code>length</code> argument, a new typed array view is created that views the specified {{jsxref("ArrayBuffer")}}. The <code>byteOffset</code> and <code>length</code> parameters specify the memory range that will be exposed by the typed array view.  If both are omitted, all of <code>buffer</code> is viewed; if only <code>length</code> is omitted, the remainder of <code>buffer</code> is viewed.</dd>
+</dl>
+
+<h2 id="Description">Description</h2>
+
+<p>ECMAScript 2015 defines a <em>TypedArray</em> constructor that serves as the <code>[[Prototype]]</code> of all <em>TypedArray</em> constructors.  This constructor is not directly exposed: there is no global <code>%TypedArray%</code> or <code>TypedArray</code> property.  It is only directly accessible through <code>Object.getPrototypeOf(Int8Array)</code> and similar.  All <em>TypedArray</em>s constructors inherit common properties from the <code>%TypedArray%</code> constructor function.  Additionally, all typed array prototypes (<em>TypedArray</em><code>.prototype</code>) have <code>%TypedArray%.prototype</code> as their <code>[[Prototype]]</code>.</p>
+
+<p>The <code>%TypedArray%</code> constructor on its own is not particularly useful.  Calling it or using it in a <code>new</code> expression will throw a <code>TypeError</code>, except when used during object creation in JS engines that support subclassing.  There are at present no such engines, so <code>%TypedArray%</code> is only useful to polyfill functions or properties onto all <em>TypedArray</em> constructors.</p>
+
+<p>When creating a <em>TypedArray </em>instance (i.e. instance of Int8Array or similar), an array buffer is created internally (if ArrayBuffer object is present as constructor argument then this array buffer is used) in memory and this buffer address is saved as internal property of that instances, and all the methods of %<code>TypedArray</code>%.<code>prototype </code>uses that array buffer address to operate on i.e. set value and get value etc.</p>
+
+<h3 id="Property_access">Property access</h3>
+
+<p>You can reference elements in the array using standard array index syntax (that is, using bracket notation). However, getting or setting indexed properties on typed arrays will not search in the prototype chain for this property, even when the indices are out of bound. Indexed properties will consult the {{jsxref("ArrayBuffer")}} and will never look at object properties. You can still use named properties, just like with all objects.</p>
+
+<pre class="brush: js">// Setting and getting using standard array syntax
+var int16 = new Int16Array(2);
+int16[0] = 42;
+console.log(int16[0]); // 42
+
+// Indexed properties on prototypes are not consulted (Fx 25)
+Int8Array.prototype[20] = 'foo';
+(new Int8Array(32))[20]; // 0
+// even when out of bound
+Int8Array.prototype[20] = 'foo';
+(new Int8Array(8))[20]; // undefined
+// or with negative integers
+Int8Array.prototype[-1] = 'foo';
+(new Int8Array(8))[-1]; // undefined
+
+// Named properties are allowed, though (Fx 30)
+Int8Array.prototype.foo = 'bar';
+(new Int8Array(32)).foo; // "bar"</pre>
+
+<h2 id="TypedArray_objects">TypedArray objects</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td class="header">Type</td>
+   <td class="header">Size in bytes</td>
+   <td class="header">Description</td>
+   <td class="header">Web IDL type</td>
+   <td class="header">Equivalent C type</td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Int8Array")}}</td>
+   <td>1</td>
+   <td>8-bit two's complement signed integer</td>
+   <td><code>byte</code></td>
+   <td><code>int8_t</code></td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Uint8Array")}}</td>
+   <td>1</td>
+   <td>8-bit unsigned integer</td>
+   <td><code>octet</code></td>
+   <td><code>uint8_t</code></td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Uint8ClampedArray")}}</td>
+   <td>1</td>
+   <td>8-bit unsigned integer (clamped)</td>
+   <td><code>octet</code></td>
+   <td><code>uint8_t</code></td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Int16Array")}}</td>
+   <td>2</td>
+   <td>16-bit two's complement signed integer</td>
+   <td><code>short</code></td>
+   <td><code>int16_t</code></td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Uint16Array")}}</td>
+   <td>2</td>
+   <td>16-bit unsigned integer</td>
+   <td><code>unsigned short</code></td>
+   <td><code>uint16_t</code></td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Int32Array")}}</td>
+   <td>4</td>
+   <td>32-bit two's complement signed integer</td>
+   <td><code>long</code></td>
+   <td><code>int32_t</code></td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Uint32Array")}}</td>
+   <td>4</td>
+   <td>32-bit unsigned integer</td>
+   <td><code>unsigned long</code></td>
+   <td><code>uint32_t</code></td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Float32Array")}}</td>
+   <td>4</td>
+   <td>32-bit IEEE floating point number</td>
+   <td><code>unrestricted float</code></td>
+   <td><code>float</code></td>
+  </tr>
+  <tr>
+   <td>{{jsxref("Float64Array")}}</td>
+   <td>8</td>
+   <td>64-bit IEEE floating point number</td>
+   <td><code>unrestricted double</code></td>
+   <td><code>double</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Properties">Properties</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.BYTES_PER_ELEMENT")}}</dt>
+ <dd>Returns a number value of the element size for the different typed array objects.</dd>
+ <dt><em>TypedArray</em>.length</dt>
+ <dd>Length property whose value is 0.</dd>
+ <dt>{{jsxref("TypedArray.name")}}</dt>
+ <dd>Returns the string value of the constructor name. E.g "Int8Array".</dd>
+ <dt>{{jsxref("TypedArray.@@species", "get TypedArray[@@species]")}}</dt>
+ <dd>The constructor function that is used to create derived objects.</dd>
+ <dt>{{jsxref("TypedArray.prototype")}}</dt>
+ <dd>Prototype for the <em>TypedArray</em> objects.</dd>
+</dl>
+
+<h2 id="Methods">Methods</h2>
+
+<dl>
+ <dt>{{jsxref("TypedArray.from()")}}</dt>
+ <dd>Creates a new typed array from an array-like or iterable object. See also {{jsxref("Array.from()")}}.</dd>
+ <dt>{{jsxref("TypedArray.of()")}}</dt>
+ <dd>Creates a new typed array with a variable number of arguments. See also {{jsxref("Array.of()")}}.</dd>
+</dl>
+
+<h2 id="TypedArray_prototype">TypedArray prototype</h2>
+
+<p>All <em>TypedArray</em>s inherit from {{jsxref("TypedArray.prototype")}}.</p>
+
+<h3 id="Properties_2">Properties</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/TypedArray/prototype','Properties')}}</p>
+
+<h3 id="Methods_2">Methods</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/TypedArray/prototype','Methods')}}</p>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('Typed Array')}}</td>
+   <td>{{Spec2('Typed Array')}}</td>
+   <td>Defined as <code>TypedArray</code> and <code>ArrayBufferView</code> interface with typed array view types. Superseded by ECMAScript 2015.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-typedarray-objects', 'TypedArray Objects')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition in an ECMA standard. Specified behaviour for indexed and named properties. Specified that <code>new</code> is required.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-typedarray-objects', 'TypedArray Objects')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(7.0)}}</td>
+   <td>{{CompatGeckoDesktop("2")}}</td>
+   <td>10</td>
+   <td>11.6</td>
+   <td>5.1</td>
+  </tr>
+  <tr>
+   <td>Indexed properties not consulting prototype</td>
+   <td>{{CompatVersionUnknown}} [1]</td>
+   <td>{{CompatGeckoDesktop("25")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Named properties</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("30")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td><code>new</code> is required</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("44")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Iterable in constructor</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("52")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>4.0</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{ CompatGeckoMobile("2") }}</td>
+   <td>10</td>
+   <td>11.6</td>
+   <td>4.2</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Indexed properties not consulting prototype</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}} [1]</td>
+   <td>{{ CompatGeckoMobile("25") }}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}} [1]</td>
+  </tr>
+  <tr>
+   <td>Named properties</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{ CompatGeckoMobile("30") }}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td><code>new</code> is required</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{ CompatGeckoMobile("44") }}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Iterable in constructor</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{ CompatGeckoMobile("52") }}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] <code>-1</code> and similar are not considered as indexed properties and therefore return the value of the prototype property.</p>
+
+<h2 id="Compatibility_notes">Compatibility notes</h2>
+
+<p>Starting with ECMAScript 2015, <code>TypedArray</code> constructors require to be constructed with a {{jsxref("Operators/new", "new")}} operator. Calling a <code>TypedArray</code> constructor as a function without <code>new</code>, will throw a {{jsxref("TypeError")}} from now on.</p>
+
+<pre class="brush: js example-bad">var dv = Int8Array([1, 2, 3]);
+// TypeError: calling a builtin Int8Array constructor
+// without new is forbidden</pre>
+
+<pre class="brush: js example-good">var dv = new Int8Array([1, 2, 3]);</pre>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays" title="en/JavaScript typed arrays">JavaScript typed arrays</a></li>
+ <li>{{jsxref("ArrayBuffer")}}</li>
+ <li>{{jsxref("DataView")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/typedarray/sort/index.html b/files/pt-br/web/javascript/reference/global_objects/typedarray/sort/index.html
new file mode 100644
index 0000000000..79481a42b5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/typedarray/sort/index.html
@@ -0,0 +1,126 @@
+---
+title: TypedArray.prototype.sort()
+slug: Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+translation_of: Web/JavaScript/Reference/Global_Objects/TypedArray/sort
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>sort()</strong></code> ordena os elementos de uma matriz tipada <em>no local</em> e retorna a matriz ordenada. Esse método tem o mesmo algoritmo que {{jsxref("Array.prototype.sort()")}}<em>.</em> <em>TypedArray</em> é uma das maneiras de <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/TypedArray#TypedArray_objects">escrever matrizes</a>.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><var>typedarray</var>.sort([<var>compareFunction</var>])</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>compareFunction</code> {{optional_inline}}</dt>
+ <dd>Especifica uma função que define a ordem de classificação.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>A matriz ordenada.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Para mais exemplos, acesse o método {{jsxref("Array.prototype.sort()")}}.</p>
+
+<pre class="brush: js">var numbers = new Uint8Array([40, 1, 5, 200]);
+numbers.sort();
+// Uint8Array [ 1, 5, 40, 200 ]
+// A compare function is not required as in the case of Array
+// to sort the numbers numerically.
+
+var numbers = [40, 1, 5, 200];
+numbers.sort();
+// The elements are sorted as strings.
+// [1, 200, 40, 5]
+
+function compareNumbers(a, b) {
+  return a - b;
+}
+
+numbers.sort(compareNumbers);
+// [ 1, 5, 40, 200 ]
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-%typedarray%.prototype.sort', 'TypedArray.prototype.sort')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-%typedarray%.prototype.sort', 'TypedArray.prototype.sort')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop(46)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Características</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile(46)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("Array.prototype.sort()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/typeerror/index.html b/files/pt-br/web/javascript/reference/global_objects/typeerror/index.html
new file mode 100644
index 0000000000..d793f767ff
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/typeerror/index.html
@@ -0,0 +1,168 @@
+---
+title: TypeError
+slug: Web/JavaScript/Reference/Global_Objects/TypeError
+translation_of: Web/JavaScript/Reference/Global_Objects/TypeError
+---
+<div>{{JSRef}}</div>
+
+<p>O  objeto <code><strong>TypeError</strong></code>  representa um erro de quando um valor não é do tipo esperado.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>new TypeError([<var>message</var>[, <var>fileName</var>[, <var>lineNumber</var>]]])</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>message</code></dt>
+ <dd>Opcional. Mensagem, descrição do erro</dd>
+ <dt><code>fileName</code> {{non-standard_inline}}</dt>
+ <dd>Opcional. O nome do arquivo contendo o código que causou a exceção</dd>
+ <dt><code>lineNumber</code> {{non-standard_inline}}</dt>
+ <dd>Opcional. O número da linha do código que causou a exeção</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O <code>TypeError</code> é ativado quando um operador ou argumento passado para uma função é incompativel com o tipo esperado por esse operador ou função.</p>
+
+<p> </p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt>{{jsxref("TypeError.prototype")}}</dt>
+ <dd>Permite a adição de propriedades para o objeto <code>TypeError</code>.</dd>
+</dl>
+
+<h2 id="Métodos">Métodos</h2>
+
+<p>O TypeError global não contém métodos por si só, no entanto, ele herda alguns métodos através da cadeia prototype.</p>
+
+<h2 id="Instâncias_TypeError"><code>Instâncias TypeError</code></h2>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError/prototype', 'Properties')}}</div>
+
+<h3 id="Métodos_2">Métodos</h3>
+
+<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypeError/prototype', 'Methods')}}</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Capturando_um_TypeError">Capturando um <code>TypeError</code></h3>
+
+<pre class="brush: js">try {
+  null.f();
+} catch (e) {
+  console.log(e instanceof TypeError); // true
+  console.log(e.message);              // "null has no properties"
+  console.log(e.name);                 // "TypeError"
+  console.log(e.fileName);             // "Scratchpad/1"
+  console.log(e.lineNumber);           // 2
+  console.log(e.columnNumber);         // 2
+  console.log(e.stack);                // "@Scratchpad/2:2:3\n"
+}
+</pre>
+
+<h3 id="Criando_um_TypeError">Criando um <code>TypeError</code></h3>
+
+<pre class="brush: js">try {
+  throw new TypeError('Hello', "someFile.js", 10);
+} catch (e) {
+  console.log(e instanceof TypeError); // true
+  console.log(e.message);              // "Hello"
+  console.log(e.name);                 // "TypeError"
+  console.log(e.fileName);             // "someFile.js"
+  console.log(e.lineNumber);           // 10
+  console.log(e.columnNumber);         // 0
+  console.log(e.stack);                // "@Scratchpad/2:2:9\n"
+}
+</pre>
+
+<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>{{SpecName('ES6', '#sec-native-error-types-used-in-this-standard-typeerror', 'TypeError')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.11.6.5', 'TypeError')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-15.11.6.5', 'TypeError')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_Navegador">Compatibilidade do Navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Error")}}</li>
+ <li>{{jsxref("TypeError.prototype")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/undefined/index.html b/files/pt-br/web/javascript/reference/global_objects/undefined/index.html
new file mode 100644
index 0000000000..2fcecff20c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/undefined/index.html
@@ -0,0 +1,175 @@
+---
+title: undefined
+slug: Web/JavaScript/Reference/Global_Objects/undefined
+translation_of: Web/JavaScript/Reference/Global_Objects/undefined
+---
+<div>
+<div>
+<div>{{jsSidebar("Objects")}}</div>
+</div>
+</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>O valor global <code>undefined</code> representa um valor indefinido. Trata-se de um dos {{Glossary("Primitivo", "tipos primitivos")}} do JavaScript.</p>
+
+<p>{{js_property_attributes(0,0,0)}}</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>undefined</code></pre>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>O <code>undefined</code> é uma propriedade do objeto <code>global</code>, ou seja, é uma variável no escopo global. O valor inicial de <code>undefined</code> é o valor primitivo <code>undefined</code>.</p>
+
+<p>Nos browsers modernos (JavaScript 1.8.5 / Firefox 4+), a especificação ECMAScript 5 define que o <code>undefined</code> é uma propriedade não configurável e somente leitura. Mesmo quando esse não for o caso, evite sobrescrevê-lo.</p>
+
+<p>Uma variável que não teve um valor atribuído é do tipo <code>undefined</code>. Um método ou sentença também retorna <code>undefined</code> se a variável que está sendo avaliada não tem um valor atribuído. Uma função retorna <code>undefined</code> se um valor não for {{jsxref("Statements/return", "retornado")}}.</p>
+
+<p>Uma vez que undefined não é uma {{jsxref("Reserved_Words", "palavra reservada")}}, ele pode ser usado como um <a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Variables">identificador</a> (nome de variável) em qualquer escopo que não seja o escopo global.</p>
+
+<pre class="brush: js">// escreve no console "foo string"
+(function(){ var undefined = 'foo'; console.log(undefined, typeof undefined); })();
+
+// escreve no console "foo string"
+(function(undefined){ console.log(undefined, typeof undefined); })('foo');
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Igualdade_estrita_()_e_undefined">Igualdade estrita (===) e <code>undefined</code></h3>
+
+<p>Voce pode utilizar <code>undefined</code> com os operadores de igualdade e desigualdade estritas para determinar se a variável possui um valor. No código a seguir, a variável <code>x</code> não foi definida, e o resultado do <code>if</code> é verdadeiro.</p>
+
+<pre class="brush: js">var x;
+if (x === undefined) {
+   // sentenças aqui são executadas
+}
+else {
+   // o código aqui não é executado
+}
+
+</pre>
+
+<div class="note"><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);">Observação: O operarador de igualdade estrita (</span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">===</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);">) tem que ser utilizado aqui uma vez que </span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">x == undefined</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);"> também checa se </span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">x</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);"> é nulo, enquanto o operador não o faz. </span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">null</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);"> não é equivalente à </span><code style="font-style: italic; color: rgba(0, 0, 0, 0.65098);">undefined</code><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);">. Veja </span><span style="color: rgba(0, 0, 0, 0.65098); font-style: italic; background-color: rgba(231, 228, 157, 0.247059);">{{jsxref("Operators/Comparison_Operators", "operadores de comparação")}} (em inglês) para maiores detalhes.</span></div>
+
+<h3 id="Operador_Typeof_e_undefined"><code>Operador Typeof</code> e <code>undefined</code></h3>
+
+<p>Alternativamente, {{jsxref("Operators/typeof", "typeof")}} pode ser usado:</p>
+
+<pre class="brush: js">var x;
+if (typeof x === 'undefined') {
+   // esse código é executado
+}
+</pre>
+
+<p>Uma das principais razões para usar o {{jsxref("Operators/typeof", "typeof")}} é que ele não lança erros caso a variável não tenha sido inicializada.</p>
+
+<pre class="brush: js">// x não foi atribuída anteriormente
+if (typeof x === 'undefined') { // returna verdadeiro sem lançar erros
+   // esse código executa
+}
+
+if(x === undefined){ // lança um ReferenceError para x
+
+}
+</pre>
+
+<p>No entanto, esse tipo de técnica deveria ser evitada. A linguagem JavaScript é uma linguagem com escopo estático, portanto o conhecimento sobre se uma variável está definida pode ser adquirido pela verificação de sua definição dentro do contexto à qual ela pertence. A única exceção é para o escopo global. No entanto, o escopo global é anexado ao objeto global, portanto a verificação da existência de uma variável no contexto global pode ser feita através de uma checagem na propriedade do objeto global usando o operador {{jsxref("Operators/in", "in")}}, por exemplo.</p>
+
+<h3 id="Operador_Void_e_undefined"><code>Operador Void</code> e <code>undefined</code></h3>
+
+<p>O  operador {{jsxref("Operators/void", "void")}} é a terceira alternativa.</p>
+
+<pre class="brush: js">var x;
+if (x === void 0) {
+   // esse código executa
+}
+
+// y não foi definido antes
+if (y === void 0) {
+   // lança uma ReferenceError (ao contrário de `typeof`)
+}
+</pre>
+
+<h2 id="Especificação">Especificação</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial. Implementado no JavaScript 1.3</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-15.1.1.3', 'undefined')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-undefined', 'undefined')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p> </p>
diff --git a/files/pt-br/web/javascript/reference/global_objects/unescape/index.html b/files/pt-br/web/javascript/reference/global_objects/unescape/index.html
new file mode 100644
index 0000000000..e3b3d2a9d1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/unescape/index.html
@@ -0,0 +1,136 @@
+---
+title: unescape()
+slug: Web/JavaScript/Reference/Global_Objects/unescape
+translation_of: Web/JavaScript/Reference/Global_Objects/unescape
+---
+<div>{{jsSidebar("Objects")}}</div>
+
+<div>{{Deprecated_header}}</div>
+
+<div>A função <strong>unescape()</strong> obsolta computa uma nova string na qual as sequencias hexadecimal são esquecidas com o caractere que representa. As sequências de escape podem ser introduzidas como funções {{jsxref("escape")}}. Porque a função 'unescape' está obsoleta, ao invez disso, use {{jsxref("decodeURI")}} ou {{jsxref("decodeURIComponent")}}.</div>
+
+<div> </div>
+
+<div class="note"><strong>Nota:</strong> Não use <code>unescape</code> para decodificar URIs, use <code>decodeURI</code> ao invez disso.</div>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox"><code>unescape(str)</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>str</code></dt>
+ <dd>Uma string a ser decodificada.</dd>
+</dl>
+
+<h3 id="Valor_retornado">Valor retornado</h3>
+
+<p>Uma nova string na qual alguns caracteres tem que ser 'unescaped'.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A função <code>unescape</code> é uma propriedade do objeto global.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<pre class="brush: js">unescape('abc123');     // "abc123"
+unescape('%E4%F6%FC');  // "äöü"
+unescape('%u0107');     // "ć"
+</pre>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES1', '#sec-15.1.2.5', 'unescape')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição Inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-B.2.2', 'unescape')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definido na compatibilidade Annex B</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-unescape-string', 'unescape')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Difinito na (normativa) Annex B Para novidades adicionais do ECMAScript para browsers</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-unescape-string', 'unescape')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Difinito na (normativa) Annex B Para novidades adicionais do ECMAScript para browsers</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidades_dos_browsers">Compatibilidades dos browsers</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Novidades</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Novidades</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("decodeURI")}}</li>
+ <li>{{jsxref("decodeURIComponent")}}</li>
+ <li>{{jsxref("escape")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/uneval/index.html b/files/pt-br/web/javascript/reference/global_objects/uneval/index.html
new file mode 100644
index 0000000000..f137fffd53
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/uneval/index.html
@@ -0,0 +1,106 @@
+---
+title: uneval()
+slug: Web/JavaScript/Reference/Global_Objects/uneval
+translation_of: Web/JavaScript/Reference/Global_Objects/uneval
+---
+<div>{{jsSidebar("Objects")}}{{Non-standard_header}}</div>
+
+<p>O  método <code><strong>uneval()</strong></code> cria uma representação do código fonte de um Objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">uneval(<var>object</var>)</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>object</code></dt>
+ <dd>A JavaScript expression or statement.</dd>
+</dl>
+
+<div class="note"><strong>Nota:</strong> Você não obterá uma representação em JSON válida para o Objeto..</div>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><code>uneval()</code> é uma função top-level e não é associada a nenhum objeto.</p>
+
+<h2 id="Examples">Examples</h2>
+
+<pre class="brush:js">var a = 1;
+uneval(a); // retorna uma String contendo 1
+
+var b = "1";
+uneval(b) // retorna uma String contendo "1"
+
+uneval(function foo(){}); // retorna"(function foo(){})"
+
+
+var a = uneval(function foo(){return 'hi'});
+var foo = eval(a);
+foo(); // retorna "hi"
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>Not part of any specifications.</p>
+
+<h2 id="Compatibilidade_dos_Navegadores">Compatibilidade dos Navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Global_Objects/eval", "eval()")}}</li>
+ <li>{{jsxref("JSON.stringify")}}</li>
+ <li>{{jsxref("JSON.parse")}}</li>
+ <li>{{jsxref("Object.toSource")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/delete/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/delete/index.html
new file mode 100644
index 0000000000..0a0d096c13
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/delete/index.html
@@ -0,0 +1,73 @@
+---
+title: WeakMap.prototype.delete()
+slug: Web/JavaScript/Reference/Global_Objects/WeakMap/delete
+translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/delete
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>delete()</strong></code> remover o elemento especificado ou setado a partir de um objeto instanciado do <code>WeakMap</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/weakmap-prototype-delete.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>wm</em>.delete(key);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>chave(key)</dt>
+ <dd>Requerido. A chave(<code>key</code>) do elemento a ser removido do objeto instanciado do <code>WeakMap</code>.</dd>
+</dl>
+
+<h3 id="Valores_retornados">Valores retornados</h3>
+
+<p><code>true</code> se o emento do objeto do <code>WeakMap</code> tenha sido removido com sucesso. <code>false</code> se a chave(<code>key</code>) não for encontrada no <code>WeakMap</code> ou se a chave(<font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">key</span></font>) não for um objeto.</p>
+
+<h2 id="Examplos">Examplos</h2>
+
+<h3 id="Usando_o_método_delete">Usando o método <code>delete</code> </h3>
+
+<pre class="brush: js;highlight:[4]">var wm = new WeakMap();
+wm.set(window, 'foo');
+
+console.log(wm.delete(window)); // Returna true. Removido com sucesso.
+
+wm.has(window);    // Returna false. O objeto window não é mais pertecente ao WeakMap.
+</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('ES2015', '#sec-weakmap.prototype.delete', 'WeakMap.prototype.delete')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-weakmap.prototype.delete', 'WeakMap.prototype.delete')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, confira A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, confira em <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> envie-nos seu pull request.</div>
+
+<p>{{Compat("javascript.builtins.WeakMap.delete")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("WeakMap")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/get/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/get/index.html
new file mode 100644
index 0000000000..fd35e8ce40
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/get/index.html
@@ -0,0 +1,74 @@
+---
+title: WeakMap.prototype.get()
+slug: Web/JavaScript/Reference/Global_Objects/WeakMap/get
+translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/get
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>get()</strong></code> retorna um elemento especificado de um objeto <code>WeakMap</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/weakmap-prototype-get.html")}}</div>
+
+<p class="hidden">A fonte para este exemplo interativo está em um repositório no GitHub. Caso você queira contribuir para o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie uma pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>wm</em>.get(chave);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>chave</dt>
+ <dd>Obrigatório. A chave do elemento a ser retornado pelo objeto <code>WeakMap</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O elemento associado à chave especificada no objeto <code>WeakMap</code>. Se a chave não for encontrada, retorna-se {{jsxref("undefined")}}.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_o_método_get">Utilizando o método <code>get</code> </h3>
+
+<pre class="brush: js">var wm = new WeakMap();
+wm.set(window, 'foo');
+
+wm.get(window); // Retorna "foo".
+wm.get('baz');  // Returna undefined.
+</pre>
+
+<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>{{SpecName('ES2015', '#sec-weakmap.prototype.get', 'WeakMap.prototype.get')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-weakmap.prototype.get', 'WeakMap.prototype.get')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.WeakMap.get")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("WeakMap")}}</li>
+ <li>{{jsxref("WeakMap.set()")}}</li>
+ <li>{{jsxref("WeakMap.has()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/has/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/has/index.html
new file mode 100644
index 0000000000..4a6795c182
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/has/index.html
@@ -0,0 +1,77 @@
+---
+title: WeakMap.prototype.has()
+slug: Web/JavaScript/Reference/Global_Objects/WeakMap/has
+translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/has
+---
+<div>{{JSRef}}</div>
+
+<p>O método <code><strong>has()</strong></code> retorna um booleano indicando se um elemento com a chave especificada existe no objeto <code>WeakMap</code> ou não.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/weakmap-prototype-has.html")}}</p>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>wm</em>.has(chave);</code></pre>
+
+<h3 id="Parameters">Parameters</h3>
+
+<dl>
+ <dt>chave</dt>
+ <dd>Obrigatório. A chave do elemento cuja presença deve ser verificada no objeto <code>WeakMap</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<dl>
+ <dt>Boolean</dt>
+ <dd>Retorna <code>true</code> se um elemento com a chave especificada existir no objeto <code>WeakMap</code>. Caso contrário, retorna <code>false</code>.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_o_método_has">Utilizando o método <code>has</code> </h3>
+
+<pre class="brush: js">var wm = new WeakMap();
+wm.set(window, 'foo');
+
+wm.has(window); // retorna true
+wm.has('baz');  // retorna false
+</pre>
+
+<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>{{SpecName('ES2015', '#sec-weakmap.prototype.has', 'WeakMap.prototype.has')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-weakmap.prototype.has', 'WeakMap.prototype.has')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.WeakMap.has")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("WeakMap")}}</li>
+ <li>{{jsxref("WeakMap.prototype.set()")}}</li>
+ <li>{{jsxref("WeakMap.prototype.get()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/index.html
new file mode 100644
index 0000000000..1069690348
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/index.html
@@ -0,0 +1,130 @@
+---
+title: WeakMap
+slug: Web/JavaScript/Reference/Global_Objects/WeakMap
+translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap
+---
+<div>{{JSRef("Global_Objects", "WeakMap")}}</div>
+
+<h2 id="Sumário">Sumário</h2>
+
+<p>O objeto WeakMap é uma coleção de pares key/value na qual as chaves são fracamente referenciadas.<br>
+ As chaves <strong>devem </strong>ser objetos, e os valores podem ser de tipos arbitrários.</p>
+
+<p>Você pode descobrir mais sobre <code>WeakMap</code>s na seção {{SectionOnPage("/en-US/docs/Web/JavaScript/Guide/Keyed_collections", "WeakMap object")}}.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>new WeakMap([iterable])
+</code></pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>iterable</code></dt>
+ <dt><span style="font-weight: normal; line-height: 1.5;">Iterable é um Array ou outro objeto iterável cujos elementos são pares key-value (Arrays de dois elementos). Cada par key-value será adicionados ao novo <code>WeakMap</code>. <code>null</code> é tratado como <code>undefined</code>.</span></dt>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<h3 id="Por_quê_WeakMap">Por quê <em>Weak</em>Map?</h3>
+
+<p><span style="line-height: 1.5;">Um programador JavaScript experiente vai notar que esta API pode ser implementada em JavaScript com dois arrays (um para chaves, um para valores) compartilhado pelos 4 métodos da API. Tal implementação teria duas principais incoveniências. A primeira é uma busca O(n) (n sendo o número de chaves no map). A segunda é o problema de memory leak. Com maps escritos manualmente, o array de chaves guardaria referências para objetos chave, prevenindo-os de serem coletados pelo Garbage Collector. Nos WeakMaps nativos, referências aos objetos chave são segurados de modo "fraco", o que significa que eles não previnem a coleção pelo GC no caso de não haver nenhuma outra referência ao objeto. </span></p>
+
+<p><span style="line-height: 1.5;">Por conta das referências serem fracas, chaves de <code>WeakMap</code> não são enumeráveis (i.e. não existe um método que dá a você uma lista de chaves). Se existisse tal método, a lista dependeria no estado da coleção do GC, introduzindo não-determinismo. Se você quiser ter uma lista de chaves, deve usar um {{jsxref("Map")}}. </span></p>
+
+<h2 id="Properties" name="Properties">Propriedades</h2>
+
+<dl>
+ <dt><code>WeakMap.length</code></dt>
+ <dd>O valor da propriedade <code>length</code> é 0.</dd>
+ <dt>{{jsxref("WeakMap.prototype")}}</dt>
+ <dd>Representa o prototype para o constructor <code>WeakMap</code>. Permite a adição de propriedades para todos os objetos <code>WeakMap</code>.</dd>
+</dl>
+
+<h2 id="Boolean_instances" name="Boolean_instances"><font face="Courier New, Andale Mono, monospace">Instâncias <code>WeakMap</code></font></h2>
+
+<p>Todas as instâncias <code>WeakMap</code> herdam de {{jsxref("WeakMap.prototype")}}.</p>
+
+<h3 id="Propriedades">Propriedades</h3>
+
+<p>{{page('pt-BR/docs/JavaScript/Reference/Global_Objects/WeakMap/prototype','Propriedades')}}</p>
+
+<h3 id="Métodos">Métodos</h3>
+
+<p>{{page('pt-BR/Web/JavaScript/Reference/Global_Objects/WeakMap/prototype','Metodos')}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_Usando_WeakMap">Exemplo: Usando <code>WeakMap</code></h3>
+
+<pre class="brush: js">var wm1 = new WeakMap(),
+    wm2 = new WeakMap(),
+    wm3 = new WeakMap();
+var o1 = {},
+    o2 = function(){},
+    o3 = window;
+
+wm1.set(o1, 37);
+wm1.set(o2, "azerty");
+wm2.set(o1, o2); // um valor pode ser qualquer coisa, incluindo um objeto or uma função
+wm2.set(o3, undefined);
+wm2.set(wm1, wm2); // chaves e valores pode ser quaisquer objetos. Até mesmo WeakMaps!
+
+wm1.get(o2); // "azerty"
+wm2.get(o2); // undefined, pois não existe valor para o2 em wm2
+wm2.get(o3); // undefined, pois este é o valor definido
+
+wm1.has(o2); // true
+wm2.has(o2); // false
+wm2.has(o3); // true (mesmo se o valor armazenado for 'undefined')
+
+wm3.set(o1, 37);
+wm3.get(o1); // 37
+wm3.clear();
+wm3.get(o1); // undefined, pois wm3 foi 'limpado' e não há mais valor para o1.
+
+wm1.has(o1);   // true
+wm1.delete(o1);
+wm1.has(o1);   // false
+</pre>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-weakmap-objects', 'WeakMap')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-weakmap-objects', 'WeakMap')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browsers">Compatibilidade com browsers</h2>
+
+<p><br>
+ {{Compat("javascript.builtins.WeakMap")}}</p>
+
+<div id="compat-mobile"> </div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=547941">WeakMap bug at Mozilla</a></li>
+ <li><a href="http://fitzgeraldnick.com/weblog/53/">Hiding Implementation Details with ECMAScript 2015 WeakMaps</a></li>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("WeakSet")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/prototype/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/prototype/index.html
new file mode 100644
index 0000000000..0baf6d569d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/prototype/index.html
@@ -0,0 +1,117 @@
+---
+title: WeakMap.prototype
+slug: Web/JavaScript/Reference/Global_Objects/WeakMap/prototype
+translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap
+---
+<div>{{JSRef("Global_Objects", "WeakMap")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>A propriedade <code><strong>WeakMap</strong></code><strong><code>.prototype</code></strong> representa o prototype fara o construtor {{jsxref("WeakMap")}}.</p>
+
+<div>{{js_property_attributes(0,0,0)}}</div>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Instâncias {{jsxref("WeakMap")}} herdam de {{jsxref("WeakMap.prototype")}}. Você pode usar o objeto <code>prototype</code> do construtor para adicionar propriedades ou métodos para todas as instâncias <code>WeakMap</code>.</p>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>WeakMap.prototype.constructor</code></dt>
+ <dd>Retorna a função construtora das instâncias, neste caso a própria <code>{{jsxref("WeakMap")}}</code>.</dd>
+</dl>
+
+<h2 id="Metodos">Metodos</h2>
+
+<dl>
+ <dt>{{jsxref("WeakMap.prototype.clear()")}}</dt>
+ <dd>Remove todos os pares chave/valor do objeto <code>WeakMap</code></dd>
+ <dt>{{jsxref("WeakMap.delete", "WeakMap.prototype.delete(key)")}}</dt>
+ <dd>Remove qualquer valor associado à  <code style="font-style: normal; line-height: 1.5;">key</code><span style="line-height: 1.5;">. </span><code style="font-style: normal; line-height: 1.5;">WeakMap.prototype.has(key)</code> e retorna <code style="font-style: normal; line-height: 1.5;">false</code> após.</dd>
+ <dt>{{jsxref("WeakMap.get", "WeakMap.prototype.get(key)")}}</dt>
+ <dd>Retorna o valor associado a <code>key</code>, ou <code>undefined</code> se nenhum existir.</dd>
+ <dt>{{jsxref("WeakMap.has", "WeakMap.prototype.has(key)")}}</dt>
+ <dd>Retorna um Boolean verificando se há algum valor associado a <code>key</code> no objeto <code>WeakMap</code> ou não.</dd>
+ <dt>{{jsxref("WeakMap.set", "WeakMap.prototype.set(key, value)")}}</dt>
+ <dd>Configura um valor para <code>key</code> no objeto <code>WeakMap</code>. Retorna <code>undefined</code>.</dd>
+</dl>
+
+<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-weakmap.prototype', 'WeakMap.prototype')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Especificação inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browsers">Compatibilidade de browsers </h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (SpiderMonkey)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("6.0")}}</td>
+   <td>11</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Firefox Mobile (SpiderMonkey)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("6.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="Notas_para_o_Chrome">Notas para o Chrome</h3>
+
+<ul>
+ <li>O recurso é ativado por preferência. Em <span style="font-family: 'Courier New','Andale Mono',monospace;">chrome://flags </span>ative "Enable Experimental JavaScript".</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map.prototype")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/weakmap/set/index.html b/files/pt-br/web/javascript/reference/global_objects/weakmap/set/index.html
new file mode 100644
index 0000000000..854f8ea816
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/weakmap/set/index.html
@@ -0,0 +1,85 @@
+---
+title: WeakMap.prototype.set()
+slug: Web/JavaScript/Reference/Global_Objects/WeakMap/set
+translation_of: Web/JavaScript/Reference/Global_Objects/WeakMap/set
+---
+<div>{{JSRef}}</div>
+
+<p>O método <strong><code>set()</code></strong> adiciona um novo elemento com a <code>chave</code> e o <code>valor</code> especificados em um objeto <code>WeakMap</code>.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/weakmap-prototype-set.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code><em>wm</em>.set(chave, valor);</code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>chave</dt>
+ <dd>Obrigatório. A chave do elemento a ser adicionado no objeto <code>WeakMap</code>.</dd>
+ <dt>valor</dt>
+ <dd>Obrigatório. O valor do elemento a ser adicionado no objeto <code>WeakMap</code>.</dd>
+</dl>
+
+<h3 id="Valor_de_retorno">Valor de retorno</h3>
+
+<p>O objeto <code>WeakMap</code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Utilizando_o_método_set">Utilizando o método <code>set</code> </h3>
+
+<pre class="brush: js">var wm = new WeakMap();
+var obj = {};
+
+// Adicionar novos elementos ao WeakMap
+wm.set(obj, 'foo').set(window, 'bar'); // encadeável
+
+// Atualizar um elemento no WeakMap
+wm.set(obj, 'baz');
+</pre>
+
+<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>{{SpecName('ES2015', '#sec-weakmap.prototype.set', 'WeakMap.prototype.set')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-weakmap.prototype.set', 'WeakMap.prototype.set')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.builtins.WeakMap.set")}}</p>
+
+<h2 id="Notas_específicas_ao_Firefox">Notas específicas ao Firefox</h2>
+
+<ul>
+ <li>Antes do Firefox 33 {{geckoRelease("33")}}, <code>WeakMap.prototype.set</code> retornava <code>undefined</code> e, portanto, não era encadeável. Isso foi resolvido ({{bug(1031632)}}). O comportamento também podia ser encontrado no Chrome/v8 (<a href="https://code.google.com/p/v8/issues/detail?id=3410">issue</a>).</li>
+</ul>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{jsxref("WeakMap")}}</li>
+ <li>{{jsxref("WeakMap.prototype.get()")}}</li>
+ <li>{{jsxref("WeakMap.prototype.has()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/global_objects/weakset/index.html b/files/pt-br/web/javascript/reference/global_objects/weakset/index.html
new file mode 100644
index 0000000000..841fce848f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/global_objects/weakset/index.html
@@ -0,0 +1,199 @@
+---
+title: WeakSet
+slug: Web/JavaScript/Reference/Global_Objects/WeakSet
+translation_of: Web/JavaScript/Reference/Global_Objects/WeakSet
+---
+<div>{{JSRef}}</div>
+
+<div>O objeto <strong>WeakSet</strong> pertmite que você armazene objetos mantidos “fracamente” na coleção.</div>
+
+<div> </div>
+
+<h2 id="Syntaxe">Syntaxe</h2>
+
+<pre class="syntaxbox"> new WeakSet([iterable]);</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt>iterable</dt>
+ <dd>Se um<a href="pt-BR/docs/Web/JavaScript/Reference/Statements/for...of"> objeto interagível </a>é passado, todos os seus elementos serão adicionados ao novo <code>WeakSet</code>.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Objetos <code>WeakSet</code> são coleções de objetos. Um objeto no <code>WeakSet </code>pode ocorrer uma vez; é único na coleção do <code>WeakSet</code>.</p>
+
+<p>As principais diferenças para o objeto {{jsxref("Set")}} são:</p>
+
+<ul>
+ <li>Em contraste ao <code>Sets</code>, <code>WeakSets </code>são <strong>coleções apenas de objetos</strong> e não de valores arbitrários de qualquer tipo.</li>
+ <li>O <code>WeakSet </code>é <em>fraco</em>. Referências aos objetos nas coleções são mantidas "fracamente". Se não há outra referência para um objeto mantido na <code>WeakSet</code>, eles pode ser coletados pelo gerenciamento de memória (<em>garbage collection</em>).</li>
+</ul>
+
+<h2 id="Propriedades">Propriedades</h2>
+
+<dl>
+ <dt><code>WeakSet.length</code></dt>
+ <dd>O valor da propriedade de  comprimento é 0.</dd>
+ <dt>{{jsxref("WeakSet.prototype")}}</dt>
+ <dd>Representa o protóripo para o construtos <code>Set</code>. Permite a adição de propriedades para todos os objetos do <code>WeakSet</code>.</dd>
+</dl>
+
+<h2 id="Instâncias_WeakSet"><code>Instâncias WeakSet</code></h2>
+
+<p>Todas as instâncias do <code>WeakSet</code> herdam do {{jsxref("WeakSet.prototype")}}.</p>
+
+<h3 id="Propriedades_2">Propriedades</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/WeakSet/prototype','Properties')}}</p>
+
+<h3 id="Métodos">Métodos</h3>
+
+<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/WeakSet/prototype','Methods')}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_o_objeto_do_WeakSet">Usando o objeto do <code>WeakSet</code></h3>
+
+<pre class="brush: js">var ws = new WeakSet();
+var obj = {};
+var foo = {};
+
+ws.add(window);
+ws.add(obj);
+
+ws.has(window); // true
+ws.has(foo);    // false, foo não foi adicionado ao set
+
+ws.delete(window); // remove window do set
+ws.has(window);    // false, window foi removido
+</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-weakset-objects', 'WeakSet')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-weakset-objects', 'WeakSet')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatilidade_de_Browser">Compatilidade de Browser</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(36)}}</td>
+   <td>{{ CompatGeckoDesktop(34) }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatOpera(23) }}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td><code>new WeakSet(iterable)</code></td>
+   <td>38</td>
+   <td>{{ CompatGeckoDesktop(34) }}</td>
+   <td>{{CompatNo}}</td>
+   <td>25</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new WeakSet(null)</code></td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("37")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td>Monkey-patched <code>add()</code> in Constructor</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("37")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>9</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatGeckoMobile(34) }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td><code>new WeakMap(iterable)</code></td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatGeckoMobile(34) }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td>Constructor argument: <code>new WeakSet(null)</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>9</td>
+  </tr>
+  <tr>
+   <td>Monkey-patched <code>add()</code> in Constructor</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>9</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Map")}}</li>
+ <li>{{jsxref("Set")}}</li>
+ <li>{{jsxref("WeakMap")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/index.html b/files/pt-br/web/javascript/reference/index.html
new file mode 100644
index 0000000000..1385db8534
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/index.html
@@ -0,0 +1,64 @@
+---
+title: Referência JavaScript
+slug: Web/JavaScript/Reference
+tags:
+  - JavaScript
+  - Referencia
+translation_of: Web/JavaScript/Reference
+---
+<h2 id="About_this_Reference" name="About_this_Reference"><a href="/en-US/docs/JavaScript/Reference/About" title="JavaScript/Reference/About">Sobre essa Referência</a></h2>
+
+<div>{{page("/pt-BR/docs/JavaScript/Reference/About")}}</div>
+
+<h2 id="Objetos_Globais"><a href="/en-US/docs/JavaScript/Reference/Global_Objects" title="JavaScript/Reference/Global_Objects">Objetos Globais</a></h2>
+
+<div>{{page('/pt-BR/docs/JavaScript/Reference/Global_Objects', 'Standard global objects (by category)')}}</div>
+
+<h2 id="Functions" name="Functions"><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope" title="JavaScript/Reference/Functions_and_function_scope">Funções e escopo de função</a></h2>
+
+
+<ul>
+ <li><code><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/arguments" title="JavaScript/Reference/Functions_and_function_scope/arguments">argumentos</a></code></li>
+ <li><a href="/en-US/docs/JavaScript/Reference/Functions_and_function_scope/Strict_mode" title="JavaScript/Reference/Functions_and_function_scope/Strict_mode">Modo Strict</a></li>
+</ul>
+
+<h2 id="Statements" name="Statements"><a href="/en-US/docs/JavaScript/Reference/Statements" title="JavaScript/Reference/Statements">Declarações</a></h2>
+
+<div>{{page('/pt-BR/docs/JavaScript/Reference/Statements')}}</div>
+
+<h2 id="Operators" name="Operators"><a href="/en-US/docs/JavaScript/Reference/Operators" title="JavaScript/Reference/Operators">Operadores e outras palavras-chave</a></h2>
+
+<div>{{page('/pt-BR/docs/JavaScript/Reference/Operators')}}</div>
+
+<h2 id="Comments" name="Comments">Comentários</h2>
+
+<ul>
+ <li><a href="/en-US/docs/JavaScript/Reference/Code_comments" title="JavaScript/Reference/Code comments">Comentários de código</a> (<code>//</code> and <code>/* */</code>)</li>
+</ul>
+
+<h2 id="E4X" name="E4X"><a href="/en-US/docs/E4X" title="E4X">E4X (extensão)</a>{{deprecated_inline}}</h2>
+
+<p>Declarações Globais:</p>
+
+<ul>
+ <li><a href="/en-US/docs/E4X/Processing_XML_with_E4X#Handling_namespaces" title="JavaScript/ Guide/Processing XML with E4X#Handling namespaces">default XML namespace</a></li>
+</ul>
+
+<p>Funções Globais:</p>
+
+<ul>
+ <li><a href="/en-US/docs/E4X:isXMLName" title="E4X:isXMLName">isXMLName()</a></li>
+</ul>
+
+<p>Construtores Globais:</p>
+
+<ul>
+ <li><a href="/en-US/docs/E4X:Namespace" title="E4X:Namespace">Namespace()</a></li>
+ <li><a href="/en-US/docs/E4X:QName" title="E4X:QName">QName()</a></li>
+ <li><a href="/en-US/docs/E4X:XML" title="E4X:XML">XML()</a></li>
+ <li><a href="/en-US/docs/E4X:XMLList" title="E4X:XMLList">XMLList()</a></li>
+</ul>
+
+<h2 id="Appendix_A_-_Reserved_Words" name="Appendix_A_-_Reserved_Words"><a href="/en-US/docs/JavaScript/Reference/Reserved_Words" title="JavaScript/Reference/Reserved_Words">Apêndice A - Palavras Reservadas</a></h2>
+
+<h2 id="Appendix_B_-_Deprecated_Features" name="Appendix_B_-_Deprecated_Features"><a href="/en-US/docs/JavaScript/Reference/Deprecated_and_obsolete_features" title="JavaScript/Reference/Deprecated_Features">Apêndice B - Funcionalidades Obsoletas</a></h2>
diff --git a/files/pt-br/web/javascript/reference/iteration_protocols/index.html b/files/pt-br/web/javascript/reference/iteration_protocols/index.html
new file mode 100644
index 0000000000..ff67030a81
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/iteration_protocols/index.html
@@ -0,0 +1,339 @@
+---
+title: Iteration protocols
+slug: Web/JavaScript/Reference/Iteration_protocols
+translation_of: Web/JavaScript/Reference/Iteration_protocols
+---
+<div>{{jsSidebar("More")}}</div>
+
+<div>Algumas adições do ECMAScript 2015 não são novos <em>built-ins</em> ou uma nova sintaxe, mas protocolos. Estes protocolos podem ser implementados por qualquer objeto desde que respeitando algumas convenções.</div>
+
+<div> </div>
+
+<div>Existem dois protocolos: O <em>protocolo iterável</em> (<a href="#The_iterable_protocol">iterable protocol</a>) e o <em>protocolo iterador </em>(<a href="#The_iterator_protocol">iterator protocol</a>).</div>
+
+<h2 id="O_protocolo_iterável_(iterable_protocol)">O protocolo iterável (iterable protocol)</h2>
+
+<p>O protocolo <strong>iterável </strong>permite que objetos JavaScript definam ou personalizem seu comportamento de iteração, como valores em um loop do construtor {{jsxref("Statements/for...of", "for..of")}}. Alguns tipos <em>built-in</em> são <em><a href="#Built-in_iterables">built-in iterables</a></em> com um comportamento de iteração padrão, tal como {{jsxref("Array")}} ou {{jsxref("Map")}}, enquanto outros tipos (como {{jsxref("Object")}}) não são assim.</p>
+
+<p>Para ser <strong>iterável</strong>, um objeto deve implementar o método <strong>@@iterator</strong>, o que significa que o objeto (ou um dos objetos acima de sua <a href="/pt-BR/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain">cadeia de protótipos</a>) deve ter uma propriedade com uma chave <strong>@@iterator </strong>que está disponível via constante <code>{{jsxref("Symbol.iterator")}}</code>:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Property</th>
+   <th scope="col">Value</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><code>[Symbol.iterator]</code></td>
+   <td>Uma função de zero argumentos que retorna um objeto, em conformidade com o <a href="/pt-BR/docs/Web/JavaScript/Reference/Iteration_protocols">protocolo iterador</a>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Sempre que um objeto precisa ser iterado (como no início de um loop <code>for..of</code>), o método <code>@@iterator</code> é chamado sem argumentos e o retorno do <strong>iterador</strong> é usado para obter os valores a serem iterados.</p>
+
+<h2 id="O_protocolo_iterador_(iterator_protocol)">O protocolo iterador (iterator protocol)</h2>
+
+<p>O protocolo <strong>iterador</strong> define uma maneira padrão de produzir uma sequência de valores (finito ou infinito).</p>
+
+<p>Um objeto é um iterador quando implementa um método <code><strong>next()</strong></code><strong> </strong>com a semântica adiante:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Propriedade</th>
+   <th scope="col">Valor</th>
+  </tr>
+  <tr>
+   <td><code>next</code></td>
+   <td>
+    <p>Uma função sem argumentos que retorna um objeto com duas propriedades:</p>
+
+    <ul>
+     <li><code>done</code> (boolean)
+
+      <ul>
+       <li>Tem o valor <code>true</code> se o iterador ultrapassar o final da sequência iterada. Nesse caso <code>value</code> opcionalmente especifica o valor de retorno do iterador. </li>
+       <li>Tem o valor <code>false</code> se o iterador foi capaz de produzir o próximo valor na sequência. Isso é equivalente a não especificar a propriedade  <code>done</code>.</li>
+      </ul>
+     </li>
+     <li><code>value</code> - qualquer valor JavaScript retornado pelo iterador. Pode ser omitido quando <code>done</code> é <code>true</code>.</li>
+    </ul>
+
+    <p>O método <code>next</code> sempre retorna um objeto com propriedades apropriadas, incluindo <code>done</code> e <code>value</code>. Se um valor não-objeto é retornado (tal como <code>false</code> ou <code>undefined</code>), será lançado um {{jsxref("TypeError")}} ("iterator.next() retorna o valor de um não-objeto").</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<div class="blockIndicator note">
+<p>Não é possível saber de forma reflexiva se um determinado objeto implementa o protocolo do iterador, no entanto, é fácil criar um objeto que satisfaça tanto o iterador quanto os protocolos iteráveis (como mostrado no exemplo abaixo). Fazer isso permite que um iterador seja consumido pelas várias sintaxes que iteráveis esperam. Assim, raramente é desejável implementar o protocolo do iterador sem também implementar iteráveis. </p>
+
+<pre class="brush: js"><code>var myIterator = {
+    next: function() {
+        // ...
+    },
+    [Symbol.iterator]: function() { return this }
+};</code>
+</pre>
+</div>
+
+<h2 id="Exemplos_de_uso_do_protocolo_de_iteração">Exemplos de uso do protocolo de iteração</h2>
+
+<p>Uma {{jsxref("String")}} é um exemplo de um objeto iterable built-in:</p>
+
+<pre class="brush: js">var someString = 'hi';
+typeof someString[Symbol.iterator];          // "function"
+</pre>
+
+<p><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/String/@@iterator">O iterador padrão</a> de uma string retorna as posições dos caracteres de uma string um por um:</p>
+
+<pre class="brush: js">var iterator = someString[Symbol.iterator]();
+iterator + '';                               // "[object String Iterator]"
+
+iterator.next();                             // { value: "h", done: false }
+iterator.next();                             // { value: "i", done: false }
+iterator.next();                             // { value: undefined, done: true }</pre>
+
+<p>Alguns construtores built-in, como <em><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Spread_syntax">spread syntax</a></em>, usam o mesmo protocolo de iteração interiormente:</p>
+
+<pre class="brush: js">[...someString]                              // ["h", "i"]</pre>
+
+<p>Podemos redefinir o comportamento de iteração fornecendo nosso próprio <code>@@iterator</code>:</p>
+
+<pre><code>var someString = new String('hi');           // need to construct a String object explicitly to avoid auto-boxing
+
+someString[Symbol.iterator] = function() {
+  return { // this is the iterator object, returning a single element, the string "bye"
+    next: function() {
+      if (this._first) {
+        this._first = false;
+        return { value: 'bye', done: false };
+      } else {
+        return { done: true };
+      }
+    },
+    _first: true
+  };
+};</code></pre>
+
+<p>Observe como redefinir <code>@@iterator</code> afeta o comportamento built-in que faz uso do protocolo de iteração:</p>
+
+<pre class="brush: js">[...someString];                             // ["bye"]
+someString + '';                             // "hi"
+</pre>
+
+<h2 id="Exemplos_de_Iteráveis">Exemplos de Iteráveis</h2>
+
+<h3 id="Iteráveis_Built-in">Iteráveis Built-in</h3>
+
+<p>{{jsxref("String")}}, {{jsxref("Array")}}, {{jsxref("TypedArray")}}, {{jsxref("Map")}} and {{jsxref("Set")}} são todos iteráveis internos, porque cada um dos seus objetos protótipos implementa um método <code>@@</code><code>iterator</code>.</p>
+
+<h3 id="Iteráveis_definidos_pelo_usuário">Iteráveis definidos pelo usuário</h3>
+
+<p>Nós podemos fazer nossos próprios iterables assim:</p>
+
+<pre><code>var myIterable = {};
+myIterable[Symbol.iterator] = function* () {
+    yield 1;
+    yield 2;
+    yield 3;
+};
+[...myIterable]; // [1, 2, 3]</code></pre>
+
+<h3 id="Built-in_APIs_que_aceitam_iteráveis">Built-in APIs que aceitam iteráveis</h3>
+
+<p>Existem muitas APIs que aceitam iteráveis, por exemplo: {{jsxref("Map", "Map([iterable])")}}, {{jsxref("WeakMap", "WeakMap([iterable])")}}, {{jsxref("Set", "Set([iterable])")}} e {{jsxref("WeakSet", "WeakSet([iterable])")}}:</p>
+
+<pre><code>var myObj = {};
+new Map([[1, 'a'], [2, 'b'], [3, 'c']]).get(2);               // "b"
+new WeakMap([[{}, 'a'], [myObj, 'b'], [{}, 'c']]).get(myObj); // "b"
+new Set([1, 2, 3]).has(3);                               // true
+new Set('123').has('2');                                 // true
+new WeakSet(function* () {
+    yield {};
+    yield myObj;
+    yield {};
+}()).has(myObj);                                         // true</code></pre>
+
+<p>Veja também {{jsxref("Promise.all", "Promise.all(iterable)")}}, {{jsxref("Promise.race", "Promise.race(iterable)")}} e {{jsxref("Array.from", "Array.from()")}}.</p>
+
+<h3 id="Sintaxe_que_espera_iteráveis">Sintaxe que espera iteráveis</h3>
+
+<p>Some statements and expressions expect iterables, for example the <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for-of</a></code> loops, <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a>, <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/yield*">yield*</a></code>, and <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment">destructuring assignment</a>:</p>
+
+<pre><code>for(let value of ['a', 'b', 'c']){
+    console.log(value);
+}
+// "a"
+// "b"
+// "c"
+
+[...'abc']; // ["a", "b", "c"]
+
+function* gen() {
+  yield* ['a', 'b', 'c'];
+}
+
+gen().next(); // { value:"a", done:false }
+
+[a, b, c] = new Set(['a', 'b', 'c']);
+a // "a"</code></pre>
+
+<h3 id="Iteráveis_não_bem_formados">Iteráveis não bem formados</h3>
+
+<p>If an iterable's <code>@@iterator</code> method doesn't return an iterator object, then it's a non-well-formed iterable. Using it as such is likely to result in runtime exceptions or buggy behavior:</p>
+
+<pre><code>var nonWellFormedIterable = {}
+nonWellFormedIterable[Symbol.iterator] = () =&gt; 1
+[...nonWellFormedIterable] // TypeError: [] is not a function</code></pre>
+
+<h2 id="Iterator_examples">Iterator examples</h2>
+
+<h3 id="Simple_iterator">Simple iterator</h3>
+
+<pre><code>function makeIterator(array) {
+    var nextIndex = 0;
+
+    return {
+       next: function() {
+           return nextIndex &lt; array.length ?
+               {value: array[nextIndex++], done: false} :
+               {done: true};
+       }
+    };
+}
+
+var it = makeIterator(['yo', 'ya']);
+
+console.log(it.next().value); // 'yo'
+console.log(it.next().value); // 'ya'
+console.log(it.next().done);  // true</code></pre>
+
+<h3 id="Infinite_iterator">Infinite iterator</h3>
+
+<pre><code>function idMaker() {
+    var index = 0;
+
+    return {
+       next: function(){
+           return {value: index++, done: false};
+       }
+    };
+}
+
+var it = idMaker();
+
+console.log(it.next().value); // '0'
+console.log(it.next().value); // '1'
+console.log(it.next().value); // '2'
+// ...</code></pre>
+
+<h3 id="Com_um_gerador">Com um gerador</h3>
+
+<pre><code>function* makeSimpleGenerator(array) {
+    var nextIndex = 0;
+
+    while (nextIndex &lt; array.length) {
+        yield array[nextIndex++];
+    }
+}
+
+var gen = makeSimpleGenerator(['yo', 'ya']);
+
+console.log(gen.next().value); // 'yo'
+console.log(gen.next().value); // 'ya'
+console.log(gen.next().done);  // true
+
+
+
+function* idMaker() {
+    var index = 0;
+    while (true)
+        yield index++;
+}
+
+var gen = idMaker();
+
+console.log(gen.next().value); // '0'
+console.log(gen.next().value); // '1'
+console.log(gen.next().value); // '2'
+// ...</code></pre>
+
+<h3 id="Com_uma_classe_ES2015">Com uma classe ES2015</h3>
+
+<pre><code>class SimpleClass {
+  constructor(data) {
+    this.index = 0;
+    this.data = data;
+  }
+
+  [Symbol.iterator]() {
+    return {
+      next: () =&gt; {
+        if (this.index &lt; this.data.length) {
+          return {value: this.data[this.index++], done: false};
+        } else {
+          this.index = 0; //If we would like to iterate over this again without forcing manual update of the index
+          return {done: true};
+        }
+      }
+    };
+  }
+}
+
+const simple = new SimpleClass([1,2,3,4,5]);
+
+for (const val of simple) {
+  console.log(val);  //'0' '1' '2' '3' '4' '5'
+}</code></pre>
+
+<h2 id="Um_objeto_gerador_um_iterador_ou_iterável">Um objeto gerador um iterador ou iterável?</h2>
+
+<p>Um objeto gerador é tanto iterador quanto iterável:</p>
+
+<pre><code>var aGeneratorObject = function* () {
+    yield 1;
+    yield 2;
+    yield 3;
+}();
+typeof aGeneratorObject.next;
+// "function", because it has a next method, so it's an iterator
+typeof aGeneratorObject[Symbol.iterator];
+// "function", because it has an @@iterator method, so it's an iterable
+aGeneratorObject[Symbol.iterator]() === aGeneratorObject;
+// true, because its @@iterator method returns itself (an iterator), so it's an well-formed iterable
+[...aGeneratorObject];
+// [1, 2, 3]</code></pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<div id="compat-desktop"> </div>
+
+<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('ES2015', '#sec-iteration', 'Iteration')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-iteration', 'Iteration')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>Para mais informações sobre <em>generators </em>ES2015, consulte <a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/function*">a documentação de function*.</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/lexical_grammar/index.html b/files/pt-br/web/javascript/reference/lexical_grammar/index.html
new file mode 100644
index 0000000000..2510942123
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/lexical_grammar/index.html
@@ -0,0 +1,683 @@
+---
+title: Gramática léxica
+slug: Web/JavaScript/Reference/Lexical_grammar
+tags:
+  - Gramática léxica
+  - JavaScript
+  - Literais
+  - Palavras-chave
+translation_of: Web/JavaScript/Reference/Lexical_grammar
+---
+<div>{{JsSidebar("More")}}</div>
+
+<p>Esta página descreve a gramática léxica da linguagem JavaScript. O código fonte de um script ECMAScript é lido da esquerda para direita e traduzido em uma sequência de elementos de entrada, como símbolos, caracteres de controle, finalizadores de linha, comentários ou espaços em branco. ECMAScript também define certas palavras-chave e literais e possui regras para inserção automática de ponto e vírgula ao final de declarações.</p>
+
+<h2 id="Caracteres_de_controle">Caracteres de controle</h2>
+
+<p> Caracteres de controle não possuem representação visual, mas são usados para controlar a interpretação do código.</p>
+
+<table class="standard-table">
+ <caption>Caracteres de controle Unicode</caption>
+ <tbody>
+  <tr>
+   <th>Código</th>
+   <th>Nome</th>
+   <th>Abreviação</th>
+   <th>Descrição</th>
+  </tr>
+  <tr>
+   <td><code>U+200C</code></td>
+   <td>
+    <p>Zero width non-joiner</p>
+   </td>
+   <td>&lt;ZWNJ&gt;</td>
+   <td>Colocado entre caracteres para evitar  que sejam visualmente ligados (fundidos) em algumas linguagens (<a href="http://en.wikipedia.org/wiki/Zero-width_non-joiner">Wikipedia</a>).</td>
+  </tr>
+  <tr>
+   <td><code>U+200D</code></td>
+   <td>
+    <p>Zero width joiner</p>
+   </td>
+   <td>&lt;ZWJ&gt;</td>
+   <td>Colocado entre caracteres que podem não estar normalmente conectados, para que estes caracteres sejam renderizados com suas devidas ligações em certas linguagens (<a href="http://en.wikipedia.org/wiki/Zero-width_joiner">Wikipedia</a>).</td>
+  </tr>
+  <tr>
+   <td><code>U+FEFF</code></td>
+   <td>Byte order mark</td>
+   <td>&lt;BOM&gt;</td>
+   <td>Usado no início do script para marcá-lo como Unicode e especificar a ordem de bytes do código (<a href="http://en.wikipedia.org/wiki/Byte_order_mark">Wikipedia</a>).</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Espaço_em_branco">Espaço em branco</h2>
+
+<p>Espaços em branco ajudam na legibilidade do código e separam os símbolos um do outro.  Estes caracteres normalmente não são funcionais no código. <a href="https://en.wikipedia.org/wiki/Minification_%28programming%29">Ferramentas de minificação</a> podem ser usadas para remover espaços em branco do código reduzindo, assim, a quantidade de dados que precisam ser transferidos.</p>
+
+<table class="standard-table">
+ <caption>Caracteres de espaço em branco</caption>
+ <tbody>
+  <tr>
+   <th>Código</th>
+   <th>Nome</th>
+   <th>Abreviação</th>
+   <th>Descrição</th>
+   <th>Sequência de escape</th>
+  </tr>
+  <tr>
+   <td>U+0009</td>
+   <td>
+    <p>Character tabulation</p>
+   </td>
+   <td>&lt;HT&gt;</td>
+   <td>Tabulação horizontal</td>
+   <td>\t</td>
+  </tr>
+  <tr>
+   <td>U+000B</td>
+   <td>
+    <p>Line tabulation</p>
+   </td>
+   <td>&lt;VT&gt;</td>
+   <td>Tabulação vertical</td>
+   <td>\v</td>
+  </tr>
+  <tr>
+   <td>U+000C</td>
+   <td>Form feed</td>
+   <td>&lt;FF&gt;</td>
+   <td>Pular para próxima página (<a href="http://en.wikipedia.org/wiki/Page_break#Form_feed">Wikipedia</a>).</td>
+   <td>\f</td>
+  </tr>
+  <tr>
+   <td>U+0020</td>
+   <td>Space</td>
+   <td>&lt;SP&gt;</td>
+   <td>Espaço normal</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>U+00A0</td>
+   <td>No-break space</td>
+   <td>&lt;NBSP&gt;</td>
+   <td>Espaço normal, sem marcar quebra de linha</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>Others</td>
+   <td>Other Unicode space characters</td>
+   <td>&lt;USP&gt;</td>
+   <td><a href="https://en.wikipedia.org/wiki/Space_%28punctuation%29#Spaces_in_Unicode">Outros tipos de espaço. Veja na Wikipedia</a></td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Finalizadores_de_linha">Finalizadores de linha</h2>
+
+<p>Além dos caracteres de espaço em branco, caracteres finalizadores de linha são usados  para melhorar a legibilidade do código. Contudo, em alguns casos, finalizadores de linha podem influenciar a execução do código JavaScript, por isso você não poderá usá-los em alguns casos. Eles também afetam o <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar$edit#Automatic_semicolon_insertion">processo automático de inserção de ponto e vírgula</a>. Em <a href="/en-US/docs/Web/JavaScript/Guide/Regular_Expressions">expressões regulares</a> os finalizadores de linha podem ser indicados com a classe <strong>\s</strong>.</p>
+
+<p>Apenas os seguintes códigos Unicode são tratados como finalizadores de linha no ECMAScript, outros caracteres de quebra de linha são tratados apenas como espaço em branco (por exemplo, Next Line, NEL, U+0085 são considerados espaço em branco).</p>
+
+<table class="standard-table">
+ <caption>Caracteres de finalização de linha</caption>
+ <tbody>
+  <tr>
+   <th>Código</th>
+   <th>Nome</th>
+   <th>Abreviação</th>
+   <th>Descrião</th>
+   <th>Sequência de escape</th>
+  </tr>
+  <tr>
+   <td>U+000A</td>
+   <td>Line Feed</td>
+   <td>&lt;LF&gt;</td>
+   <td>Caractere de nova linha em sistemas UNIX.</td>
+   <td>\n</td>
+  </tr>
+  <tr>
+   <td>U+000D</td>
+   <td>Carriage Return</td>
+   <td>&lt;CR&gt;</td>
+   <td>Caractere de nova linha nos sistemas Commodore e nos primeiros Mac's.</td>
+   <td>\r</td>
+  </tr>
+  <tr>
+   <td>U+2028</td>
+   <td>Line Separator</td>
+   <td>&lt;LS&gt;</td>
+   <td><a href="http://en.wikipedia.org/wiki/Newline">Wikipedia</a></td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>U+2029</td>
+   <td>Paragraph Separator</td>
+   <td>&lt;PS&gt;</td>
+   <td><a href="http://en.wikipedia.org/wiki/Newline">Wikipedia</a></td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Comentários">Comentários</h2>
+
+<p>Comentários são usados para inserir dicas, notas, sugestões ou alertas no código JavaScript. Isto pode tornar mais fácil ler ou entender o que o código faz. Também pode ser usado para desabilitar código, evitando sua execução; isto pode ser uma valiosa ferramenta na hora de debugar seu código.</p>
+
+<p>JavaScript possui duas formas de inserir comentário no código.</p>
+
+<p>O primeiro é com o uso de duas barras <code>//</code>; isso faz com que qualquer coisa escrita a seguir, e na mesma linha, se torne comentário. Por exemplo:</p>
+
+<pre class="brush: js">function comment() {
+  // Isto é um comentário de uma linha em JavaScript
+  console.log('Hello world!');
+}
+comment();
+</pre>
+
+<p>A segunda forma é com o uso de <code>/* */</code>, que é muito mais flexível.</p>
+
+<p>Por exemplo, você pode usá-lo em uma única linha:</p>
+
+<pre class="brush: js">function comment() {
+  /* Isto é um comentário de uma linha em JavaScript */
+  console.log('Hello world!');
+}
+comment();</pre>
+
+<p>Ou pode fazer um comentário de várias linhas, desta forma:</p>
+
+<pre class="brush: js">function comment() {
+  /* Este é um comentário de várias linhas. Observe que
+ não precisamos encerrar o comentário até terminar. */
+  console.log('Hello world!');
+}
+comment();</pre>
+
+<p>Você também pode usá-lo no meio de uma linha, se quiser, porém isto pode tornar seu código mais difícil de ler, portanto use com cautela:</p>
+
+<pre class="brush: js">function comment(x) {
+  console.log('Hello ' + x /* insira o valor de x */ + ' !');
+}
+comment('world');</pre>
+
+
+
+<p>Além disso, você pode usá-lo para desativar algum código para evitar que seja executado, envolvendo o código em um comentário, assim:</p>
+
+<pre class="brush: js">function comment() {
+  /* console.log('Hello world!'); */
+}
+comment();</pre>
+
+<p>Neste caso, a função <code>console.log()</code> nunca será invocada, pois está comentada. Qualquer quantidade de linhas de código podem ser desabilitadas desta forma.</p>
+
+<h2 id="Palavras-chave">Palavras-chave</h2>
+
+<h3 id="Palavras-chave_reservadas_do_ECMAScript_2015">Palavras-chave reservadas do ECMAScript 2015</h3>
+
+<ul class="threecolumns">
+ <li>{{jsxref("Statements/break", "break")}}</li>
+ <li>{{jsxref("Statements/switch", "case")}}</li>
+ <li>{{jsxref("Statements/try...catch", "catch")}}</li>
+ <li>{{jsxref("Statements/class", "class")}}</li>
+ <li>{{jsxref("Statements/const", "const")}}</li>
+ <li>{{jsxref("Statements/continue", "continue")}}</li>
+ <li>{{jsxref("Statements/debugger", "debugger")}}</li>
+ <li>{{jsxref("Statements/default", "default")}}</li>
+ <li>{{jsxref("Operators/delete", "delete")}}</li>
+ <li>{{jsxref("Statements/do...while", "do")}}</li>
+ <li>{{jsxref("Statements/if...else", "else")}}</li>
+ <li>{{jsxref("Statements/export", "export")}}</li>
+ <li>{{jsxref("Statements/class", "extends")}}</li>
+ <li>{{jsxref("Statements/try...catch", "finally")}}</li>
+ <li>{{jsxref("Statements/for", "for")}}</li>
+ <li>{{jsxref("Statements/function", "function")}}</li>
+ <li>{{jsxref("Statements/if...else", "if")}}</li>
+ <li>{{jsxref("Statements/import", "import")}}</li>
+ <li>{{jsxref("Operators/in", "in")}}</li>
+ <li>{{jsxref("Operators/instanceof", "instanceof")}}</li>
+ <li>{{jsxref("Operators/new", "new")}}</li>
+ <li>{{jsxref("Statements/return", "return")}}</li>
+ <li>{{jsxref("Operators/super", "super")}}</li>
+ <li>{{jsxref("Statements/switch", "switch")}}</li>
+ <li>{{jsxref("Operators/this", "this")}}</li>
+ <li>{{jsxref("Statements/throw", "throw")}}</li>
+ <li>{{jsxref("Statements/try...catch", "try")}}</li>
+ <li>{{jsxref("Operators/typeof", "typeof")}}</li>
+ <li>{{jsxref("Statements/var", "var")}}</li>
+ <li>{{jsxref("Operators/void", "void")}}</li>
+ <li>{{jsxref("Statements/while", "while")}}</li>
+ <li>{{jsxref("Statements/with", "with")}}</li>
+ <li>{{jsxref("Operators/yield", "yield")}}</li>
+</ul>
+
+<h3 id="Palavras-chave_reservadas_para_uso_futuro">Palavras-chave reservadas para uso futuro</h3>
+
+<p>As seguintes palavras-chave estão reservadas para uso futuro na especificação ECMAScript. Atualmente elas não tem funcionalidade, mas poderão ter no futuro, portanto elas também não podem ser usadas como identificadores.</p>
+
+<p>Estes sempre são reservados:</p>
+
+<ul>
+ <li><code>enum</code></li>
+</ul>
+
+<p>Os seguintes são reservados apenas quando o código está em modo estrito (<em>strict mode</em>):</p>
+
+<ul class="threecolumns">
+ <li><code>implements</code></li>
+ <li><code>interface</code></li>
+ <li>{{jsxref("Statements/let", "let")}}</li>
+ <li><code>package</code></li>
+ <li><code>private</code></li>
+ <li><code>protected</code></li>
+ <li><code>public</code></li>
+ <li><code>static</code></li>
+</ul>
+
+<p>Os seguintes são reservados apenas quando são encontrados no código do módulo:</p>
+
+<ul>
+ <li><code>await</code></li>
+</ul>
+
+<h4 id="Palavras-chave_reservadas_para_uso_futuro_em_versões_antigas">Palavras-chave reservadas para uso futuro em versões antigas</h4>
+
+<p>As seguintes palavras-chave foram reservadas para uso futuro em especificações antigas do ECMAScript (ECMAScript 1 até 3).</p>
+
+<ul class="threecolumns">
+ <li><code>abstract</code></li>
+ <li><code>boolean</code></li>
+ <li><code>byte</code></li>
+ <li><code>char</code></li>
+ <li><code>double</code></li>
+ <li><code>final</code></li>
+ <li><code>float</code></li>
+ <li><code>goto</code></li>
+ <li><code>int</code></li>
+ <li><code>long</code></li>
+ <li><code>native</code></li>
+ <li><code>short</code></li>
+ <li><code>synchronized</code></li>
+ <li><code>throws</code></li>
+ <li><code>transient</code></li>
+ <li><code>volatile</code></li>
+</ul>
+
+<p>Além disso, os literais <code>null</code>, <code>true</code>, e <code>false</code> não podem ser usados como identificadores em ECMAScript.</p>
+
+<h3 id="Uso_de_palavras-chave_reservadas">Uso de palavras-chave reservadas</h3>
+
+<p>Palavras reservadas atualmente só não podem ser usadas como identificadores . Como descrito em <a href="http://es5.github.com/#A.1">es5.github.com/#A.1</a>, não há problema em usar <font face="consolas, Liberation Mono, courier, monospace">palavras reservadas desta forma</font>.</p>
+
+<pre class="brush: js">a.import
+a['import']
+a = { import: 'test' }.
+</pre>
+
+<p>Por outro lado, o seguinte é ilegal por quê a palavra reservada "<em>import</em>" está sendo usada como identificador. Identificadores podem ser usados em declaração de expressões e funções.</p>
+
+<pre class="brush: js">function import() {} // Proibido.</pre>
+
+<h2 id="Literais">Literais</h2>
+
+<h3 id="Null">Null</h3>
+
+<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a> para mais informações.</p>
+
+<pre class="brush: js">null</pre>
+
+<h3 id="Booleanos">Booleanos</h3>
+
+<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean"><code>Boolean</code></a> para mais informações.</p>
+
+<pre class="brush: js">true
+false</pre>
+
+<h3 id="Números">Números</h3>
+
+<h4 id="Decimal">Decimal</h4>
+
+<pre class="brush: js">1234567890
+42
+
+// Cuidado com o uso precedido de zero:
+0888 // 888 convertido como decimal
+0777 // Convertido como octal, 511 em decimal
+</pre>
+
+<p>Veja que números decimais podem começar com zero (<code>0</code>) seguido de outro dígito decimal, porém se todos dígitos após o zero inicial forem menores que 8, o número é interpretado como um número octal. Isso não vai disparar um erro em JavaScript, veja {{bug(957513)}}. Veja também esta página sobre conversão de tipo <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/parseInt#Octal_interpretations_with_no_radix"><code>parseInt()</code></a>.</p>
+
+<h4 id="Binário">Binário</h4>
+
+<p>Números binários em JavaScript são iniciados em zero seguido da letra "B" em maiúsculo ou minúsculo (<code>0b</code> ou <code>0B</code>). Esta sintaxe é nova no ECMAScript 2015, por isso verifique a compatibilidade do navegador. Se o dígito seguinte ao <code>0b</code> não for 0 ou 1, o seguinte <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">erro de sintaxe</a> é disparado: "Missing binary digits after 0b".</p>
+
+<pre class="brush: js">var FLT_SIGNBIT  = 0b10000000000000000000000000000000; // 2147483648
+var FLT_EXPONENT = 0b01111111100000000000000000000000; // 2139095040
+var FLT_MANTISSA = 0B00000000011111111111111111111111; // 8388607</pre>
+
+<h4 id="Octal">Octal</h4>
+
+<p>Números octais em JavaScript são escritos com zero inicial seguido da letra "O" em maiúsculo ou minúsculo (<code>0o</code> ou <code>0O)</code>. Esta sintaxe é nova no ECMAScript 2015, por isso verifique a compatibilidade do navegador. Se os dígitos após o <code>0o não forem octais válidos</code> (01234567), o seguinte <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">erro de sintaxe</a> será disparado:  "Missing octal digits after 0o".</p>
+
+<pre class="brush: js">var n = 0O755; // 493
+var m = 0o644; // 420
+
+// Também é possível com apenas um zero no início (veja sobre decimais acima)
+0755
+0644
+</pre>
+
+<h4 id="Hexadecimal">Hexadecimal</h4>
+
+<p>Números hexadecimais em JavaScript são iniciados com zero seguido da letra "X" em maiúsculo ou minúsculo (<code>0x</code> ou <code>0X)</code>. Se os dígitos após o 0x não forem hexadecimais válidos (0123456789ABCDEF),  o seguinte <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">erro de sintaxe</a> será disparado: "Identifier starts immediately after numeric literal".</p>
+
+<pre class="brush: js">0xFFFFFFFFFFFFFFFFF // 295147905179352830000
+0x123456789ABCDEF   // 81985529216486900
+0XA                 // 10
+</pre>
+
+<h3 id="Objetos">Objetos</h3>
+
+<p>Veja também {{jsxref("Object")}} e <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">Object initializer</a> para mais informações.</p>
+
+<pre class="brush: js">var o = { a: 'foo', b: 'bar', c: 42 };
+
+// Notação curta. Novidade no ES2015
+var a = 'foo', b = 'bar', c = 42;
+var o = {a, b, c};
+
+// instead of
+var o = { a: a, b: b, c: c };
+</pre>
+
+<h3 id="Arrays">Arrays</h3>
+
+<p>Veja também {{jsxref("Array")}} para mais informações.</p>
+
+<pre class="brush: js">[1954, 1974, 1990, 2014]</pre>
+
+<h3 id="Strings">Strings</h3>
+
+<pre class="brush: js">'foo'
+"bar"</pre>
+
+<h4 id="Caracteres_de_escape_em_hexadecimal">Caracteres de escape em hexadecimal</h4>
+
+<pre class="brush: js">'\xA9' // "©"
+</pre>
+
+<h4 id="Caracteres_de_escape_em_Unicode">Caracteres de escape em Unicode</h4>
+
+<p>A representação de caracteres de escape em Unicode requer ao menos quatro caracteres após o  <code>\u</code>.</p>
+
+<pre class="brush: js">'\u00A9' // "©"</pre>
+
+<h4 id="Codificação_de_caracteres_Unicode">Codificação de caracteres Unicode </h4>
+
+<p>Novidade no ECMAScript 2015. Com a codificação de caracteres Unicode qualquer caractere pode ser representado usando sequência hexadecimal, desta forma podemos representar caracteres Unicode com sequência hexadecimal até <code>0x10FFFF</code>. Usando apenas Unicode, muitas vezes pode ser necessário utilizar mais de uma sequência para conseguir o mesmo resultado.</p>
+
+<p>Veja também {{jsxref("String.fromCodePoint()")}} ou {{jsxref("String.prototype.codePointAt()")}}.</p>
+
+<pre class="brush: js">'\u{2F804}'
+
+// O mesmo usando apenas Unicode
+'\uD87E\uDC04'</pre>
+
+<h3 id="Expressões_regulares">Expressões regulares</h3>
+
+<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp"><code>RegExp</code></a> para mais informações.</p>
+
+<pre class="brush: js">/ab+c/g
+
+// Um "espaço vazio" em expressão regular
+// Para evitar confusão com comentário de linha única
+// faça o seguinte:
+/(?:)/</pre>
+
+<h3 id="Templates">Templates</h3>
+
+<p>Veja também <a href="/en-US/docs/Web/JavaScript/Reference/template_strings">template strings</a> para mais informações .</p>
+
+<pre class="brush: js">`texto`
+
+`linha de texto 1
+ linha de texto 2`
+
+`texto ${expressão} texto`
+
+tag `texto ${expressão} texto`</pre>
+
+<h2 id="Inserção_automática_de_ponto_e_vírgula">Inserção automática de ponto e vírgula</h2>
+
+<p> Algumas <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements">declarações</a> JavaScript precisam ser finalizadas com ponto e vírgula e, por isso, são afetadas pelo mecanismo automático de inserção de ponto evírgula (na silga ASI, em inglês):</p>
+
+<ul>
+ <li>Declaração vazia</li>
+ <li><code>let</code>, <code>const</code>, declaração de variável</li>
+ <li><code>import</code>, <code>export</code>, declaração module</li>
+ <li>Expressões</li>
+ <li><code>debugger</code></li>
+ <li><code>continue</code>, <code>break</code>, <code>throw</code></li>
+ <li><code>return</code></li>
+</ul>
+
+<p>A especificação ECMAScript menciona <a href="https://tc39.github.io/ecma262/#sec-rules-of-automatic-semicolon-insertion">três regras para inserção de ponto e vírgula</a>.</p>
+
+<p>1.  Um ponto e vírgula é inserido antes, quando um <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar$edit#Line_terminators">finalizador de linha</a> ou um "}" é encontrado em local não permitido pela sintaxe.</p>
+
+<pre class="brush: js">{ 1 2 } 3
+
+// É transformado pelo ASI em
+
+{ 1 2 ;} 3;</pre>
+
+<p>2.  Um ponto e vírgula é inserido ao final, quando o sinal de final de linha é detectado e o conversor não é capaz de unir a linha seguinte em um único comando.</p>
+
+<p>Aqui o <code>++ não é interpretado como <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment">operador de incremento</a> aplicado à variável b por que há um finalizador de linha entre o b e ++</code> .</p>
+
+<pre class="brush: js">a = b
+++c
+
+// É transformado pelo ASI em
+
+a = b;
+++c;
+</pre>
+
+<p>3.  Um ponto e vírgula é inserido ao final quando uma declaração com regra léxica restrita é encontrada seguida de um finalizador de linha. As declaraçõs sem regra específica de finalizador de linha são:</p>
+
+<ul>
+ <li>Operadores de incremento ou decremento (<code>++</code> and <code>--</code>)</li>
+ <li><code>continue</code></li>
+ <li><code>break</code></li>
+ <li><code>return</code></li>
+ <li><code>yield</code>, <code>yield*</code></li>
+ <li><code>module</code></li>
+</ul>
+
+<pre class="brush: js">return
+a + b
+
+// É transformado pelo ASI em
+
+return;
+a + b;
+</pre>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2("ES1")}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-7', 'Lexical Conventions')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-ecmascript-language-lexical-grammar', 'Lexical Grammar')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Adicionado: números Binarios e Octais, Unicode code point, Templates</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-ecmascript-language-lexical-grammar', 'Lexical Grammar')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Binary and octal numeric literals<br>
+    (<code>0b</code> and <code>0o</code>)</td>
+   <td>{{CompatChrome(41)}}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop(25)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOpera(28)}}</td>
+   <td>{{CompatSafari(9)}}</td>
+  </tr>
+  <tr>
+   <td>Unicode code point escapes<br>
+    (<code>\u{}</code>)</td>
+   <td>{{CompatChrome(44)}}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop(40)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera(31)}}</td>
+   <td>{{CompatSafari(9)}}</td>
+  </tr>
+  <tr>
+   <td>Shorthand notation for object literals</td>
+   <td>{{CompatChrome(43)}}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop(33)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(30)}}</td>
+   <td>{{CompatSafari(9)}}</td>
+  </tr>
+  <tr>
+   <td>Template literals</td>
+   <td>{{CompatChrome(41)}}</td>
+   <td>12</td>
+   <td>{{CompatGeckoDesktop(34)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatOpera(28)}}</td>
+   <td>{{CompatSafari(9)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Binary and octal numeric literals (<code>0b</code> and <code>0o</code>)</td>
+   <td>{{CompatUnknown}}</td>
+   <td>41</td>
+   <td>{{CompatGeckomobile(33)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Unicode code point escapes (<code>\u{}</code>)</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckomobile(40)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Shorthand notation for object literals</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(33)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Template literals</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile(34)}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Firefox-notas_específicas">Firefox-notas específicas</h2>
+
+<ul>
+ <li>Em versões anteriores ao Firefox 5 (JavaScript 1.8.6) palavras reservadas para uso futuro não pdem ser usadas em strict mode. Essa falha de ECMAScript foi corrigida no Firefox 5.</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="http://whereswalden.com/2013/08/12/micro-feature-from-es6-now-in-firefox-aurora-and-nightly-binary-and-octal-numbers/">Jeff Walden: Binary and octal numbers</a></li>
+ <li><a href="http://mathiasbynens.be/notes/javascript-escapes">Mathias Bynens: JavaScript character escape sequences</a></li>
+ <li>{{jsxref("Boolean")}}</li>
+ <li>{{jsxref("Number")}}</li>
+ <li>{{jsxref("RegExp")}}</li>
+ <li>{{jsxref("String")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/arithmetic_operators/index.html b/files/pt-br/web/javascript/reference/operators/arithmetic_operators/index.html
new file mode 100644
index 0000000000..d3f99a9315
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/arithmetic_operators/index.html
@@ -0,0 +1,328 @@
+---
+title: Arithmetic operators
+slug: Web/JavaScript/Reference/Operators/Arithmetic_Operators
+tags:
+  - JavaScript
+  - Operadores
+translation_of: Web/JavaScript/Reference/Operators
+---
+<div>{{jsSidebar("Operadores")}}</div>
+
+<p><strong>Operadores aritméticos</strong> tem valores numéricos (literais ou variáveis) como seus operadores e retornam um valor numérico único. Os operadores aritméticos padrões são adição (+), subtração (-), multiplicação (*), e divisão (/).</p>
+
+<h2 id="Adição_()"><a name="Addition">Adição (+)</a></h2>
+
+<p>O operador de adição produz a soma dos operadores numéricos ou a concatenação de strings.</p>
+
+<h3 id="Sintaxe">Sintaxe</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x + y
+</pre>
+
+<h3 id="Exemplos">Exemplos</h3>
+
+<pre class="brush: js">// Número + Número -&gt; adição
+1 + 2 // 3
+
+// Booleano + Número -&gt; adição
+true + 1 // 2
+
+// Booleano + Booleano -&gt; adição
+false + false // 0
+
+// Número + String -&gt; concatenação
+5 + "foo" // "5foo"
+
+// String + Booleano -&gt; concatenação
+"foo" + false // "foofalse"
+
+// String + String -&gt; concatenação
+"foo" + "bar" // "foobar"
+</pre>
+
+<h2 id="Subtração_(-)"><a name="Subtraction">Subtração (-)</a></h2>
+
+<p>O operador de subtração subtrai os dois operandos, produzindo sua diferença.</p>
+
+<h3 id="Sintaxe_2">Sintaxe</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x - y
+</pre>
+
+<h3 id="Exemplos_2">Exemplos</h3>
+
+<pre class="brush: js">5 - 3 // 2
+3 - 5 // -2
+"foo" - 3 // NaN</pre>
+
+<h2 id="Divisão_()"><a name="Division">Divisão (/)</a></h2>
+
+<p>O operador de divisão produz o quociente de seus operandos onde o operando da esquerda é o dividendo e o da direita é o divisor.</p>
+
+<h3 id="Sintaxe_3">Sintaxe</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x / y
+</pre>
+
+<h3 id="Exemplos_3">Exemplos</h3>
+
+<pre class="brush: js">1 / 2      // retorna 0.5 em JavaScript
+1 / 2      // retorna 0 em Java
+// (nenhum dos números é explicitamente um número de ponto flutuante)
+
+1.0 / 2.0  // retorna 0.5 em JavaScript e Java
+
+2.0 / 0    // retorna Infinity em JavaScript
+2.0 / 0.0  // retorna Infinity também
+2.0 / -0.0 // retorna -Infinity em JavaScript</pre>
+
+<h2 id="Multiplicação_(*)"><a name="Multiplication">Multiplicação (*)</a></h2>
+
+<p>O operador de multiplicação produz o produto dos operandos.</p>
+
+<h3 id="Sintaxe_4">Sintaxe</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x * y
+</pre>
+
+<h3 id="Exemplos_4">Exemplos</h3>
+
+<pre class="brush: js">2 * 2 // 4
+-2 * 2 // -4
+Infinity * 0 // NaN
+Infinity * Infinity // Infinity
+"foo" * 2 // NaN
+</pre>
+
+<h2 id="Módulo_()"><a name="Remainder">Módulo (%)</a></h2>
+
+<p>O operador de módulo retorna o primeiro operando módulo o segundo, isto é, var1 módulo var2, na sentença anterior, onde var1 e var 2 são variáveis. A função módulo é o resto inteiro da divisão de var1 por var2. <a href="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator" title="http://wiki.ecmascript.org/doku.php?id=strawman:modulo_operator">Existe uma proposta de ter um operador real de módulo em uma versão futura do ECMAScript.</a></p>
+
+<h3 id="Sintaxe_5">Sintaxe</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> var1 % var2
+</pre>
+
+<h3 id="Examples">Examples</h3>
+
+<pre class="brush: js">12 % 5 // 2
+-1 % 2 // -1
+NaN % 2 // NaN
+</pre>
+
+<h2 id="Exponenciação_(**)"><a id="Exponenciação" name="Exponenciação">Exponenciação (**)</a></h2>
+
+<p>O operador de exponenciação retorna o resultado do primeiro operando elevado ao segundo operando. É o mesmo que <code>var1</code><sup><code>var2</code></sup>, onde <code>var1</code> e <code>var2</code> são variáveis. O operador de exponenciação é associativo à direita, ou seja, <code>a ** b ** c</code> é igual a <code>a ** (b ** c)</code>.</p>
+
+<h3 id="Sintaxe_6">Sintaxe</h3>
+
+<pre><strong>Operador:</strong> var1 ** var2
+</pre>
+
+<h3 id="Notas">Notas</h3>
+
+<p>Em várias linguagens como PHP e Python e outras que tem o operador de exponenciação (**), a exponenciação tem prioridade do que operações unárias, como + e  -, mas tem algumas exceções. Por exemplo, no Bash o operador ** é definido por ter menos prioridade do que operadores unários. No JavaScript, é impossível escrever uma expressão de exponenciação ambígua, i.e. você não pode colocar um operador unário (<code>+/-/~/!/delete/void/typeof</code>) imediatamente antes do número base.</p>
+
+<pre>-2 ** 2;
+// 4 no Bash, -4 em outras linguagens.
+// Isso é inválido no JavaScript, pois a operação é ambígua.
+
+
+-(2 ** 2);
+// -4 no JavaScript e a intenção do autor não é ambígua.
+</pre>
+
+<h3 id="Exemplos_5">Exemplos</h3>
+
+<pre>2 ** 3 // 8
+3 ** 2 // 9
+3 ** 2.5 // 15.588457268119896
+10 ** -1 // 0.1
+NaN ** 2 // NaN
+
+2 ** 3 ** 2 // 512
+2 ** (3 ** 2) // 512
+(2 ** 3) ** 2 // 64
+</pre>
+
+<p>Para inverter o sinal do resultado de uma expressão de exponenciação:</p>
+
+<pre>-(2 ** 2) // -4
+</pre>
+
+<p>Para forçar a base de uma expressão de exponenciação para ser um número negativo:</p>
+
+<pre>(-2) ** 2 // 4
+</pre>
+
+<div class="note">
+<p><strong>Nota:</strong> JavaScript também tem  <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR">um operador de lógica binária ^ (XOR)</a>. <code>**</code> e <code>^</code> são diferentes (por exemplo : <code>2 ** 3 === 8</code> enquanto <code>2 ^ 3 === 1</code>.)</p>
+</div>
+
+<h2 id="Incremento_()"><a name="Increment">Incremento (++)</a></h2>
+
+<p>O operador de incremento incrementa (adiciona um a) seu operando e retorna um valor;</p>
+
+<ul>
+ <li>Se usado na forma posfixa, com o operador depois do operando (por exemplo, x++), então ele retorna o valor antes de incrementá-lo.</li>
+ <li>Se usado na forma prefixa, com o operador antes do operando (por exemplo, ++x), então ele retorna o valor depois de incrementá-lo.</li>
+</ul>
+
+<h3 id="Sintaxe_7">Sintaxe</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x++ or ++x
+</pre>
+
+<h3 id="Exemplos_6">Exemplos</h3>
+
+<pre class="brush: js">// Posfixo
+var x = 3;
+y = x++; // y = 3, x = 4
+
+// Prefixo
+var a = 2;
+b = ++a; // a = 3, b = 3
+</pre>
+
+<h2 id="Decremento_(--)"><a name="Decrement">Decremento (--)</a></h2>
+
+<p>O operador de decremento decrementa (subtrai um de) seu operando e retorna um valor.</p>
+
+<ul>
+ <li>Se usado na forma posfixa (por exemplo, x--), então ele retorna o valor antes de decrementá-lo.</li>
+ <li>Se usado na forma prefixa (por exemplo, --x), então ele retorna o valor depois de decrementá-lo.</li>
+</ul>
+
+<h3 id="Sintaxe_8">Sintaxe</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> x-- or --x
+</pre>
+
+<h3 id="Exemplos_7">Exemplos</h3>
+
+<pre class="brush: js">// Posfixo
+var x = 3;
+y = x--; // y = 3, x = 2
+
+// Prefixo
+var a = 2;
+b = --a; // a = 1, b = 1
+</pre>
+
+<h2 id="Negação_Unária_(-)"><a name="Unary_negation">Negação Unária (-)</a></h2>
+
+<p>O operador de negação unária precede seu operando e o nega.</p>
+
+<h3 id="Sintaxe_9">Sintaxe</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> -x
+</pre>
+
+<h3 id="Exemplos_8">Exemplos</h3>
+
+<pre class="brush: js">var x = 3;
+y = -x; // y = -3, x = 3
+</pre>
+
+<h2 id="Soma_Unária_()"><a name="Unary_plus">Soma Unária</a> (+)</h2>
+
+<p>O operador de soma unária precede seu operando e calcula para seu operando mas tenta convertê-lo para um número, caso ainda não o seja. Apesar da negação unária (-) também poder converter não-números, a soma unária é a forma mais rápida e a forma preferida de converter alguma coisa em um número, porque ele não realiza nenhuma outra operação no número. Ele pode converter strings que representam inteiros e ponto flutuante, bem como os valores de não-string <code>true</code>, <code>false</code>, e <code>null</code>. Inteiros em formato decimal e hexadecimal ("0x"-prefixado) são suportados. Números negativos são suportados (não os hexadecimais). Caso não possa analisar um determinado valor, o operador retornará <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN">NaN</a>.</p>
+
+<h3 id="Sintaxe_10">Sintaxe</h3>
+
+<pre class="syntaxbox"><strong>Operador:</strong> +x
+</pre>
+
+<h3 id="Exemplos_9">Exemplos</h3>
+
+<pre class="brush: js">+3     // 3
++"3"   // 3
++true  // 1
++false // 0
++null  // 0
+</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>ECMAScript 1ª Edição.</td>
+   <td>Padrão</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.3')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definido em várias seções da especificação: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Operadores aditivos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.5">Operadores Multiplicativos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.3">Expressões Posfixas</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Operadores Unários</a>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-postfix-expressions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definido em várias seções da especificação: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.6">Operadores aditivos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.5">Operadores Multiplicativos</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.3">Expressões Posfixas</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4">Operadores Unários</a>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operatores de atribuição</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/array_comprehensions/index.html b/files/pt-br/web/javascript/reference/operators/array_comprehensions/index.html
new file mode 100644
index 0000000000..c035f757d7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/array_comprehensions/index.html
@@ -0,0 +1,207 @@
+---
+title: Array comprehensions
+slug: Web/JavaScript/Reference/Operators/Array_comprehensions
+tags:
+  - Array
+  - ECMAScript7
+  - JavaScript
+  - Operador
+translation_of: Archive/Web/JavaScript/Array_comprehensions
+---
+<p>{{jsSidebar("Operators")}}</p>
+
+<h2 id="Sumário">Sumário</h2>
+
+<p> </p>
+
+<p><span class="seoSummary"><span style="line-height: 19.0909080505371px;">A sintaxe de </span><strong style="line-height: 19.0909080505371px;">array comprehension</strong><span style="line-height: 19.0909080505371px;"> trata-se de uma expressão JavaScript que lhe permite rapidamente montar um novo array com base em outro já existente. As comprehensions já existem em várias outras linguagens e estarão então presentes no padrão ECMAScript 7.</span></span></p>
+
+<p>Veja abaixo as diferenças para a antiga implementação no SpiderMOnkey, baseado nas propostas para o ECMAScript 4.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">[for (x of iterable) x]
+[for (x of iterable) if (condition) x]
+[for (x of iterable) for (y of iterable) x + y]
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Dentro de array comprehensions dois tipos de components são permitidos: </p>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a> e</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else">if</a></li>
+</ul>
+
+<p>A iteração por for-of deve sempre, ser a primeira componente. Multiplos <code>for-of</code> ou <code>if</code>s podem  também ser permitidos.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Array_comprehensions_simples">Array comprehensions simples</h3>
+
+<pre class="brush:js">[for (i of [ 1, 2, 3 ]) i*i ];
+// [ 1, 4, 9 ]
+
+var abc = [ "A", "B", "C" ];
+[for (letters of abc) letters.toLowerCase()];
+// [ "a", "b", "c" ]</pre>
+
+<h3 id="Array_comprehensions_com_if">Array comprehensions com <code>if</code></h3>
+
+<pre class="brush: js">var years = [ 1954, 1974, 1990, 2006, 2010, 2014 ];
+[for (year of years) if (year &gt; 2000) year];
+// [ 2006, 2010, 2014 ]
+[for (year of years) if (year &gt; 2000) if(year &lt; 2010) year];
+// [ 2006], the same as below:
+[for (year of years) if (year &gt; 2000 &amp;&amp; year &lt; 2010) year];
+// [ 2006]
+</pre>
+
+<h3 id="Array_comprehensions_comparado_a_map_e_filter">Array comprehensions comparado a <code>map</code> e <code>filter</code></h3>
+
+<p>Um modo fácil de entender a sintaxe de array comprehension é comparar com os métodos {{jsxref("Array.map", "map")}} e {{jsxref("Array.filter", "filter")}}:</p>
+
+<pre class="brush: js">var numbers = [ 1, 2, 3 ];
+
+numbers.map(function (i) { return i * i });
+[for (i of numbers) i*i ];
+// both is [ 1, 4, 9 ]
+
+numbers.filter(function (i) { return i &lt; 3 });
+[for (i of numbers) if (i &lt; 3) i];
+// both is [ 1, 2 ]
+</pre>
+
+<h3 id="Array_comprehensions_com_dois_arrays">Array comprehensions com dois arrays</h3>
+
+<p>Utilizando dois iteradores <code>for-of, com dois arrays:</code></p>
+
+<pre class="brush: js">var numbers = [ 1, 2, 3 ];
+var letters = [ "a", "b", "c" ];
+
+var cross = [for (i of numbers) for (j of letters) i+j];
+// [ "1a", "1b", "1c", "2a", "2b", "2c", "3a", "3b", "3c" ]
+
+var grid = [for (i of numbers) [for (j of letters) i+j]];
+// [
+//  ["1a", "1b", "1c"],
+//  ["2a", "2b", "2c"],
+//  ["3a", "3b", "3c"]
+// ]
+
+[for (i of numbers) if (i &gt; 1) for (j of letters) if(j &gt; "a") i+j]
+// ["2b", "2c", "3b", "3c"], the same as below:
+
+[for (i of numbers) for (j of letters) if (i &gt; 1) if(j &gt; "a") i+j]
+// ["2b", "2c", "3b", "3c"]
+
+[for (i of numbers) if (i &gt; 1) [for (j of letters) if(j &gt; "a") i+j]]
+// [["2b", "2c"], ["3b", "3c"]], not the same as below:
+
+[for (i of numbers) [for (j of letters) if (i &gt; 1) if(j &gt; "a") i+j]]
+// [[], ["2b", "2c"], ["3b", "3c"]]
+</pre>
+
+<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>Proposed for ECMAScript 7</td>
+   <td>No draft available yet</td>
+   <td>Estava inicialmente no rascunho para o ES6, porém foi removido na revisão 27 (Agosto, 2014). Veja as revisões antigas do ES6 para especificações de semântica. Uma versão atualizada estará de volta em um novo rascunho do ES7.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatGeckoDesktop("30") }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatGeckoMobile("30") }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+   <td>{{ CompatNo() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="Notas_sobre_implementações_para_o_SpiderMonkey">Notas sobre implementações para o SpiderMonkey</h3>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a> como um idenficador não é suportado, assim let está recentemente disponível somente para JS versão 1.7 e tags de scripts XUL.</li>
+ <li>Destruturação em comprehensions ainda não é suportado ({{bug(980828)}}).</li>
+</ul>
+
+<h3 id="Diferenças_para_as_antiga_JS1.7JS1.8_comprehensions">Diferenças para as antiga JS1.7/JS1.8 comprehensions</h3>
+
+<ul>
+ <li>Comprehensions no ES7 criam um escopo para cada nó de <font face="Courier New, Andale Mono, monospace">for<code> ao invés da comprehension toda</code></font>
+
+  <ul>
+   <li>Antigo: <code>[()=&gt;x for (x of [0, 1, 2])][1]() // 2</code></li>
+   <li>Novo: <code>[for (x of [0, 1, 2]) ()=&gt;x][1]() // 1, cada iteração cria uma nova binding para o </code>x.</li>
+  </ul>
+ </li>
+ <li>Comprehensions no ES7 iniciam com <code>for</code> ao invés de expressão de assinalamento.
+  <ul>
+   <li>Antigo: <code>[i * 2 for (i of numbers)]</code></li>
+   <li>Novo: <code>[for (i of numbers) <code>i * 2</code>]</code></li>
+  </ul>
+ </li>
+ <li>Comprehensions no ES7 podem ter multiplos <code>if</code> e <code>for</code>.</li>
+ <li>Comprehensions no ES7 funcionam apenas com <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a></code> e não com iterações <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a>.</code></li>
+</ul>
+
+<h2 id="See_also" name="See_also">Veja Também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a></li>
+ <li>{{jsxref("Operators/Generator_comprehensions", "Generator comprehensions", "" ,1)}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/async_function/index.html b/files/pt-br/web/javascript/reference/operators/async_function/index.html
new file mode 100644
index 0000000000..fbd7674f47
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/async_function/index.html
@@ -0,0 +1,152 @@
+---
+title: Expressão da função async
+slug: Web/JavaScript/Reference/Operators/async_function
+tags:
+  - Experimental
+  - Expressão Primária
+  - Função
+  - Operador
+translation_of: Web/JavaScript/Reference/Operators/async_function
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<div>A palavra chave async pode ser usado para definir funções async dentro das expressões.</div>
+
+<div>Você tambem pode definir funções async usando a declaração de função async.</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">async function [<em>nome</em>]([<em>parametro1</em>[, <em>parametro2[</em>, ..., <em>parametroN</em>]]]) {
+    <em>declarações</em>
+}</pre>
+
+<p>Como no  <a href="https://developer.mozilla.org/en-US/docs/">ES2015</a>, você tambem pode usar  <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a>.</p>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>nome</code></dt>
+ <dd>O nome da função.Pode ser omitida, na qual a função se torna anonima . O nome é somente local para o corpo da função.</dd>
+ <dt><code>parametroN</code></dt>
+ <dd>O nome do argumento passado para a função.</dd>
+ <dt><code>declarações</code></dt>
+ <dd>As declarações que compoem o corpo da função .</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Uma expressão <code>async function</code> é muito similar, e tem quase a mesma sintaxe de uma {{jsxref('Statements/async_function', 'declaração async function')}}. A principal diferença entre uma expressão <code>async function </code>e uma declaração <code>async function</code> é o <em>nome da função</em><em>,</em> que pode ser omitido em expressões <code>async function</code> para criar <em>funções anônimas</em>. Uma expressão <code>async function</code> pode ser utilizada como um {{Glossary("IIFE")}} (Immediately Invoked Function Expression, em tradução livre: Expressão de Função Invocada Imediatamente) que roda assim que definido. Veja também o capítulo sobre <a href="/en-US/docs/Web/JavaScript/Reference/Functions">funções</a> para mais informações.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_simples">Exemplo simples</h3>
+
+<pre class="brush: js">function resolveAfter2Seconds(x) {
+  return new Promise(resolve =&gt; {
+    setTimeout(() =&gt; {
+      resolve(x);
+    }, 2000);
+  });
+};
+
+(async function(x) { // async function expression usada como uma IIFE
+  var a = resolveAfter2Seconds(20);
+  var b = resolveAfter2Seconds(30);
+  return x + await a + await b;
+})(10).then(v =&gt; {
+  console.log(v);  // imprime 60 após 2 segundo.
+});
+
+var add = async function(x) { // async function expression atribuída a uma variável
+  var a = await resolveAfter2Seconds(20);
+  var b = await resolveAfter2Seconds(30);
+  return x + a + b;
+};
+
+add(10).then(v =&gt; {
+  console.log(v);  // imprime 60 após 4 segundos.
+});
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-async-function-definitions', 'async function')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definição inicial no ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th> Edge</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(55)}}</td>
+   <td>{{CompatGeckoDesktop("52.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOpera(42)}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("52.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOpera(42)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatChrome(55)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/async_function", "async function")}}</li>
+ <li>{{jsxref("AsyncFunction")}} object</li>
+ <li>{{jsxref("Operators/await", "await")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/atribuicao_via_desestruturacao/index.html b/files/pt-br/web/javascript/reference/operators/atribuicao_via_desestruturacao/index.html
new file mode 100644
index 0000000000..6b1a100b4b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/atribuicao_via_desestruturacao/index.html
@@ -0,0 +1,445 @@
+---
+title: Atribuição via desestruturação (destructuring assignment)
+slug: Web/JavaScript/Reference/Operators/Atribuicao_via_desestruturacao
+translation_of: Web/JavaScript/Reference/Operators/Destructuring_assignment
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>A sintaxe de <strong>atribuição via desestruturação (destructuring assignment)</strong> é uma expressão JavaScript que possibilita extrair dados de arrays ou objetos em variáveis distintas.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush:js notranslate">var a, b, rest;
+[a, b] = [1, 2];
+console.log(a); // 1
+console.log(b); // 2
+
+[a, b, ...rest] = [1, 2, 3, 4, 5];
+console.log(a); // 1
+console.log(b); // 2
+console.log(rest); // [3, 4, 5]
+
+({a, b} = {a:1, b:2});
+console.log(a); // 1
+console.log(b); // 2
+
+// ES2016 - não implementado em Firefox 47a01
+({a, b, ...rest} = {a:1, b:2, c:3, d:4});
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>As expressões de objeto e matriz literais fornecem uma maneira fácil de criar pacotes <em>ad hoc</em> de dados .</p>
+
+<pre class="brush: js notranslate">var x = [1, 2, 3, 4, 5];</pre>
+
+<p>A atribuição via desestruturação usa sintaxe similar, mas no lado esquerdo da atribuição são definidos quais elementos devem ser extraídos da variável de origem.</p>
+
+<pre class="brush: js notranslate">var x = [1, 2, 3, 4, 5];
+var [y, z] = x;
+console.log(y); // 1
+console.log(z); // 2
+</pre>
+
+<p>Esse recurso é semelhante aos recursos presentes em linguagens como Perl e Python.</p>
+
+<h2 id="Desestruturação_de_array">Desestruturação de array</h2>
+
+<h3 id="Atribuição_básica_de_variável">Atribuição básica de variável</h3>
+
+<pre class="brush: js notranslate">var foo = ["one", "two", "three"];
+
+var [one, two, three] = foo;
+console.log(one); // "one"
+console.log(two); // "two"
+console.log(three); // "three"
+</pre>
+
+<h3 id="Atribuição_separada_da_declaração">Atribuição separada da declaração</h3>
+
+<p>Uma variável pode ter seu valor atribuído via desestruturação separadamente da declaração dela.</p>
+
+<pre class="brush:js notranslate">var a, b;
+
+[a, b] = [1, 2];
+console.log(a); // 1
+console.log(b); // 2
+</pre>
+
+<h3 id="Valores_padrão">Valores padrão</h3>
+
+<p>Uma variável pode ser atribuída de um padrão, no caso em que o valor retirado do array é undefined.</p>
+
+<pre class="brush: js notranslate">var a, b;
+
+[a=5, b=7] = [1];
+console.log(a); // 1
+console.log(b); // 7
+</pre>
+
+<h3 id="Trocando_variáveis">Trocando variáveis</h3>
+
+<p>Os valores de duas variáveis podem ser trocados em uma expressão de desestruturação.</p>
+
+<p>Sem atribuição via desestruturação, trocar dois valores requer uma variável temporária (ou, em algumas linguagens de baixo nível, o <a class="external" href="https://pt.wikipedia.org/wiki/Algoritmo_XOR_Swap">Algoritmo XOR Swap</a>).</p>
+
+<pre class="brush:js notranslate">var a = 1;
+var b = 3;
+
+[a, b] = [b, a];
+console.log(a); // 3
+console.log(b); // 1
+</pre>
+
+<h3 id="Analisando_um_array_retornado_de_uma_função">Analisando um array retornado de uma função</h3>
+
+<p>Sempre foi possível retornar uma matriz de uma função. A desestruturação pode tornar mais conciso o trabalho com um valor de retorno do tipo array.</p>
+
+<p>Neste exemplo, <code>f()</code> returna os valores <code>[1, 2]</code> como saída, que podem ser analisados em uma única linha com desestruturação.</p>
+
+<pre class="brush:js notranslate">function f() {
+  return [1, 2];
+}
+
+var a, b;
+[a, b] = f();
+console.log(a); // 1
+console.log(b); // 2
+</pre>
+
+<h3 id="Ignorando_alguns_valores_retornados">Ignorando alguns valores retornados</h3>
+
+<p>Você pode ignorar valores retornados que você não tem interesse:</p>
+
+<pre class="brush:js notranslate">function f() {
+  return [1, 2, 3];
+}
+
+var [a, , b] = f();
+console.log(a); // 1
+console.log(b); // 3
+</pre>
+
+<p>Você também pode ignorar todos os valores retornados:</p>
+
+<pre class="brush:js notranslate">[,,] = f();
+</pre>
+
+<h3 id="Atribuindo_o_resto_de_um_array_para_uma_variável">Atribuindo o resto de um array para uma variável</h3>
+
+<p>Ao desestruturar um array, você pode atribuir a parte restante deste em uma viáriável usando o padrão rest:</p>
+
+<pre class="brush: js notranslate">var [a, ...b] = [1, 2, 3];
+console.log(a); // 1
+console.log(b); // [2, 3]</pre>
+
+<h3 id="Extraindo_valores_do_resultado_de_uma_expressão_regular">Extraindo valores do resultado de uma expressão regular</h3>
+
+<p>Quando o método de expressão regular <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec">exec()</a></code> encontra um resultado, ele retorna um array que contém primeiro toda a porção resultante da string e depois cada uma das porções da string resultante envolvidas por parênteses na expressão regular. A atribuição via desestruturação lhe permite extrair as partes desses array facilmente, ignorando a porção resultante completa se não precisar.</p>
+
+<pre class="brush:js notranslate">var url = "https://developer.mozilla.org/en-US/Web/JavaScript";
+
+var parsedURL = /^(\w+)\:\/\/([^\/]+)\/(.*)$/.exec(url);
+console.log(parsedURL); // ["https://developer.mozilla.org/en-US/Web/JavaScript", "https", "developer.mozilla.org", "en-US/Web/JavaScript"]
+
+var [, protocol, fullhost, fullpath] = parsedURL;
+
+console.log(protocol); // "https"
+</pre>
+
+<h2 id="Desestruturação_de_objeto">Desestruturação de objeto</h2>
+
+<h3 id="Atribuição_básica">Atribuição básica</h3>
+
+<pre class="brush: js notranslate">var o = {p: 42, q: true};
+var {p, q} = o;
+
+console.log(p); // 42
+console.log(q); // true
+</pre>
+
+<h3 id="Atribuição_sem_declaração">Atribuição sem declaração</h3>
+
+<p>Uma variável pode ter seu valor atribuído via desestruturação separadamente da sua declaração.</p>
+
+<pre class="brush:js notranslate">var a, b;
+
+({a, b} = {a:1, b:2});</pre>
+
+<div class="note">
+<p>Os parênteses <code>( ... )</code> ao redor da declaração de atribuição é uma sintaxe necessária  quando se utiliza a atribuição via desestruturação de objeto literal sem uma declaração.</p>
+
+<p><code>{a, b} = {a:1, b:2}</code> não é uma sintaxe stand-alone válida, pois <code>{a, b}</code> no lado esquerdo é considarada um bloco, não um objeto literal.</p>
+
+<p>No entanto, <code>({a, b} = {a:1, b:2})</code> é valida, assim como <code>var {a, b} = {a:1, b:2}</code></p>
+</div>
+
+<h3 id="Atribuição_para_variáveis_com_novos_nomes">Atribuição para variáveis com novos nomes</h3>
+
+<p>Uma variável pode ser extraída de um objeto e atribuída a uma variável com um nome diferente da propriedade do objeto.</p>
+
+<pre class="brush: js notranslate">var o = {p: 42, q: true};
+var {p: foo, q: bar} = o;
+
+console.log(foo); // 42
+console.log(bar); // true  </pre>
+
+<h3 id="Valores_padrão_2">Valores padrão</h3>
+
+<p>Uma variável pode ser atribuída de um padrão, no caso em que o valor retirado do objeto é undefined.</p>
+
+<pre class="brush: js notranslate">var {a=10, b=5} = {a: 3};
+
+console.log(a); // 3
+console.log(b); // 5</pre>
+
+<h3 id="Definindo_um_valor_padrão_de_parâmetro_de_função">Definindo um valor padrão de parâmetro de função</h3>
+
+<h4 id="Versão_ES5">Versão ES5</h4>
+
+<pre class="brush: js notranslate">function drawES5Chart(options) {
+  options = options === undefined ? {} : options;
+  var size = options.size === undefined ? 'big' : options.size;
+  var cords = options.cords === undefined ? { x: 0, y: 0 } : options.cords;
+  var radius = options.radius === undefined ? 25 : options.radius;
+  console.log(size, cords, radius);
+  // now finally do some chart drawing
+}
+
+drawES5Chart({
+  cords: { x: 18, y: 30 },
+  radius: 30
+});</pre>
+
+<h4 id="Versão_ES2015">Versão ES2015</h4>
+
+<pre class="brush: js notranslate">function drawES2015Chart({size = 'big', cords = { x: 0, y: 0 }, radius = 25} = {}) {
+  console.log(size, cords, radius);
+  // do some chart drawing
+}
+
+drawES2015Chart({
+  cords: { x: 18, y: 30 },
+  radius: 30
+});</pre>
+
+<h3 id="Objeto_aninhado_e_desestruturação_de_array">Objeto aninhado e desestruturação de array</h3>
+
+<pre class="brush:js notranslate">var metadata = {
+    title: "Scratchpad",
+    translations: [
+       {
+        locale: "de",
+        localization_tags: [ ],
+        last_edit: "2014-04-14T08:43:37",
+        url: "/de/docs/Tools/Scratchpad",
+        title: "JavaScript-Umgebung"
+       }
+    ],
+    url: "/en-US/docs/Tools/Scratchpad"
+};
+
+var { title: englishTitle, translations: [{ title: localeTitle }] } = metadata;
+
+console.log(englishTitle); // "Scratchpad"
+console.log(localeTitle);  // "JavaScript-Umgebung"</pre>
+
+<h3 id="For_de_iteração_e_desestruturação">For de iteração e desestruturação</h3>
+
+<pre class="brush: js notranslate">var people = [
+  {
+    name: "Mike Smith",
+    family: {
+      mother: "Jane Smith",
+      father: "Harry Smith",
+      sister: "Samantha Smith"
+    },
+    age: 35
+  },
+  {
+    name: "Tom Jones",
+    family: {
+      mother: "Norah Jones",
+      father: "Richard Jones",
+      brother: "Howard Jones"
+    },
+    age: 25
+  }
+];
+
+for (var {name: n, family: { father: f } } of people) {
+  console.log("Name: " + n + ", Father: " + f);
+}
+
+// "Name: Mike Smith, Father: Harry Smith"
+// "Name: Tom Jones, Father: Richard Jones"</pre>
+
+<h3 id="Extraindo_campos_de_objetos_passados_como_parâmetro_de_função">Extraindo campos de objetos passados como parâmetro de função</h3>
+
+<pre class="brush:js notranslate">function userId({id}) {
+  return id;
+}
+
+function whois({displayName: displayName, fullName: {firstName: name}}){
+  console.log(displayName + " is " + name);
+}
+
+var user = {
+  id: 42,
+  displayName: "jdoe",
+  fullName: {
+      firstName: "John",
+      lastName: "Doe"
+  }
+};
+
+console.log("userId: " + userId(user)); // "userId: 42"
+whois(user); // "jdoe is John"</pre>
+
+<p>Isso extrai o <code>id</code>, <code>displayName</code> e <code>firstName</code> do objeto <code>user</code> e os imprime na tela.</p>
+
+<h3 id="Nomes_computados_de_propriedade_de_objeto_e_desestruturação">Nomes computados de propriedade de objeto e desestruturação</h3>
+
+<p>Nomes computados de propriedades, como em <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer#Computed_property_names">objetos literais</a>, podem ser usados com desestruturação.</p>
+
+<pre class="brush: js notranslate">let key = "z";
+let { [key]: foo } = { z: "bar" };
+
+console.log(foo); // "bar"
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Espeficiação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-destructuring-assignment', 'Destructuring assignment')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-destructuring-assignment', 'Destructuring assignment')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Edge</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>
+    <p>Suporte básico</p>
+   </td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoDesktop("1.8.1") }}</td>
+   <td>14</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>
+    <p>Nomes computados de propriedades</p>
+   </td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoDesktop("34") }}</td>
+   <td>14</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Operador spread</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoDesktop("34") }}</td>
+   <td>12<sup>[1]</sup></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoMobile("1.0") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+   <td>{{CompatChrome(49.0)}}</td>
+  </tr>
+  <tr>
+   <td>Nomes computados de propriedades</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoMobile("34") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+  </tr>
+  <tr>
+   <td>Operador spread</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+   <td>{{ CompatGeckoMobile("34") }}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatChrome(49.0)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Requer "Enable experimental Javascript features" para funciona sob `about:flags`</p>
+
+<h2 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h2>
+
+<ul>
+ <li>O Firefox forneceu uma extensão não-padronizada de linguagem em <a href="/en-US/docs/Web/JavaScript/New_in_JavaScript/1.7">JS1.7</a> para desestruturação. Esta extensão foi removida no Gecko 40 {{geckoRelease (40)}}. Consulte {{bug (1083498)}}.</li>
+ <li>A partir do Gecko 41 {{geckoRelease (41)}} e para cumprir com a especificação ES2015, padrões de desestruturação com parênteses, como <code>([a, b]) = [1, 2]</code> or <code>({a, b}) = { a: 1, b: 2 }</code>, agora são considerados inválidos e lançarão um {{jsxref ( "SyntaxError")}}. Veja a postagem no blog de Jeff Walden e {{bug (1146136)}} para mais detalhes.</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/Assignment_Operators">Operadores de Atribuição</a></li>
+ <li><a href="https://hacks.mozilla.org/2015/05/es6-in-depth-destructuring/">"ES6 in Depth: Destructuring" on hacks.mozilla.org (em inglês)</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/await/index.html b/files/pt-br/web/javascript/reference/operators/await/index.html
new file mode 100644
index 0000000000..c37d10bf4b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/await/index.html
@@ -0,0 +1,152 @@
+---
+title: await
+slug: Web/JavaScript/Reference/Operators/await
+tags:
+  - Experimental
+  - JavaScript
+  - Operador
+translation_of: Web/JavaScript/Reference/Operators/await
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>O operador <code>await</code> é utilizado para esperar por uma {{jsxref("Promise")}}. Ele pode ser usado apenas dentro de uma {{jsxref("Statements/async_function", "async function")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">[<em>rv</em>] = await <em>expressão</em>;</pre>
+
+<dl>
+ <dt><code>expressão</code></dt>
+ <dd>Uma {{jsxref("Promise")}} ou qualquer valor para esperar uma resolução.</dd>
+ <dt><code>rv</code></dt>
+ <dd>
+ <p>Retorna um valor final da promise, ou o próprio valor se ele não for uma <code>Promise</code>.</p>
+ </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A expressão <code>await</code> faz a execução de uma função <code>async</code> pausar, para esperar pelo retorno da <code>Promise</code>, e resume a execução da função <code>async</code> quando o valor da Promise é resolvido. Ele então retorna o valor final da Promise. Se esse valor não for uma <code>Promise</code>, ele é convertido para uma <code>Promise </code>resolvida.</p>
+
+<p>Se a <code>Promise</code> for rejeitada, a expressão <code>await</code> invoca uma Exception com o valor rejeitado.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Se uma <code>Promise</code> é passada para uma expressão <code>await</code>, ele espera pela sefinalização da <code>Promise</code> e retorna seu valor final.</p>
+
+<pre class="brush: js">function resolveAfter2Seconds(x) {
+  return new Promise(resolve =&gt; {
+    setTimeout(() =&gt; {
+      resolve(x);
+    }, 2000);
+  });
+}
+
+async function f1() {
+  var x = await resolveAfter2Seconds(10);
+  console.log(x); // 10
+}
+f1();
+</pre>
+
+<p>Se o valor não for uma <code>Promise</code>, ele converte o valor para uma <code>Promise </code>resolvida,  e espera por ele.</p>
+
+<pre class="brush: js">async function f2() {
+  var y = await 20;
+  console.log(y); // 20
+}
+f2();</pre>
+
+<p>Se a <code>Promise</code> for rejeitada, o valor rejeitado é invocado em uma Exception.</p>
+
+<pre class="brush: js">async function f3() {
+  try {
+    var z = await Promise.reject(30);
+  } catch(e) {
+    console.log(e); // 30
+  }
+}
+f3();</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-async-function-definitions', 'async functions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definição inicial no ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(55)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("52.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOpera(42)}}</td>
+   <td>10.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android Webview</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(55)}}</td>
+   <td>{{CompatChrome(55)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("52.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatOperaMobile(42)}}</td>
+   <td>10.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/async_function", "async function")}}</li>
+ <li>{{jsxref("Operators/async_function", "async function expression")}}</li>
+ <li>{{jsxref("AsyncFunction")}} object</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/bitwise_operators/index.html b/files/pt-br/web/javascript/reference/operators/bitwise_operators/index.html
new file mode 100644
index 0000000000..7e9d2de505
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/bitwise_operators/index.html
@@ -0,0 +1,558 @@
+---
+title: Bitwise operators
+slug: Web/JavaScript/Reference/Operators/Bitwise_Operators
+translation_of: Web/JavaScript/Reference/Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<div></div>
+
+<div>Operadores bit-a-bit são são operadores tratados como sequência de 32 bits ( zeros e uns ), preferencialmente como decimal, hexadecimal, ou números octais. Por exemplo, o número decimal 9 tinha como representação binária de 1001. Operadores bit-a-bit realizam as operações em tais representações binárias, mas retornam valores numéricos no padrão Javascript.</div>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwiseoperators.html")}}</div>
+
+<p class="hidden">O código para este interactivo exemplo está armazenado em um repositório GitHub . Se você quiser contribuir para o projeto exemplo interativo, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e mande-nos um pull request.</p>
+
+<p>A seguinte tabela resume os Operadores bit-a-bit:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th>Operador</th>
+   <th>Uso</th>
+   <th>Descrição</th>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(Bitwise_AND)">Bitwise AND</a></td>
+   <td><code>a &amp; b</code></td>
+   <td>Retorna <code>1</code> em cada posição de bit para à qual o bit correspondente de ambos eram <code>1</code>s.</td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(Bitwise_OR)">Bitwise OR</a></td>
+   <td><code>a | b</code></td>
+   <td>
+    <p>Retorna 1 para cada posição de bit para à qual o correspondente de um ou ambos eram <code>1</code>s.</p>
+   </td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(Bitwise_XOR)">Bitwise XOR</a></td>
+   <td><code>a ^ b</code></td>
+   <td>Retorna 1 para cada posição de bit para à qual o bit correspondente de um mas não ambos eram <code>1</code>s.</td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#(Bitwise_NOT)">Bitwise NOT</a></td>
+   <td><code>~ a</code></td>
+   <td>Inverte os bits de seus operandos.</td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3C%3C_(Left_shift)">Left shift</a></td>
+   <td><code>a &lt;&lt; b</code></td>
+   <td>Jogam <code>a</code>  em representação binária <code>b</code> (&lt; 32) bits à esquerda, mudando de zeros à diretia.</td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3E%3E_(Sign-propagating_right_shift)">Sign-propagating right shift</a></td>
+   <td><code>a &gt;&gt; b</code></td>
+   <td>Jogam <code>a</code>  em representação binária <code>b</code> (&lt; 32) bits à direita, descartando bits que foram tornados off.</td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#%3E%3E%3E_(Zero-fill_right_shift)">Zero-fill right shift</a></td>
+   <td><code>a &gt;&gt;&gt; b</code>  </td>
+   <td>Jogam <code>a</code>  em representação binária <code>b</code> (&lt; 32) bits à direita, descartando bits que foram tornados off, e jogando <code>0</code>s para à esquerda.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Inteiros_assinados_em_32-bit">Inteiros assinados em 32-bit</h2>
+
+<p>Os operandos de todos os operadores bit-a-bit são assinados como inteiros de 32-bit em duas formas complementares. Duas formas complementares significa que uma negativa contrapartida (e.g. 5 vs. -5) são todos os bits daqueles números invertidos (bit-a-bit NOT de um número, a.k.a. complementos de um número) mais um. Por example, os seguintes encodes inteiros são 314:</p>
+
+<pre class="brush: js">00000000000000000000000100111010
+</pre>
+
+<p>Os seguintes encodes <code>~314</code>, i.e. são os únicos complementos de  <code>314</code>:</p>
+
+<pre class="brush: js">11111111111111111111111011000101
+</pre>
+
+<p>Finalmente, os seguintes encodes <code>-314,</code> i.e. são dois complementos de <code>314</code>:</p>
+
+<pre class="brush: js">11111111111111111111111011000110
+</pre>
+
+<p>As duas garantias complementares daquele bit mais à esquerda que é zero quando o número é positivo e 1 quando o número é negativo. Aliás, isto é chamado de <em>sign bit </em>ou <em>bit assinalado.</em></p>
+
+<p>O número 0 é o inteiro composto completamente de 0 bits.</p>
+
+<pre class="brush: js">0 (base 10) = 00000000000000000000000000000000 (base 2)
+</pre>
+
+<p>O número <code>-1</code> é o inteiro que é composto completamente de 1 bits.</p>
+
+<pre class="brush: js">-1 (base 10) = 11111111111111111111111111111111 (base 2)
+</pre>
+
+<p>O número <code>-2147483648</code> (representação hexadecimal: <code>-0x80000000</code>) é o inteiro completamente composto de 0 bits exceto o primeiro (left-most) único.</p>
+
+<pre class="brush: js">-2147483648 (base 10) = 10000000000000000000000000000000 (base 2)
+</pre>
+
+<p>O número <code>2147483647</code> (representação hexadecimal: <code>0x7fffffff</code>) é o inteiro composto completamente por bits 1, exceto pelo primeiro (o mais à esquerda).</p>
+
+<pre class="brush: js">2147483647 (base 10) = 01111111111111111111111111111111 (base 2)
+</pre>
+
+<p>Os números <code>-2147483648</code> e <code>2147483647</code> são, respectivamente, o minimo e o máximo inteiro representáveis atráves de um número de 32 bits assinados.</p>
+
+<h2 id="Operadores_lógico_bit-abit">Operadores lógico bit-abit</h2>
+
+<p>Conceitualmente, os operadores lógicos bit-abit funcionam da seguinte forma:</p>
+
+<ul>
+ <li>Os operandos são convertidos para inteiros de 32 bits e expressados em uma série de bits (zeros e ums). Números com mais de 32 bits têm seus bits mais significativos descartados. Por exemplo, o inteiro com mais de 32 bits a seguir será convertido para um inteiro de 32 bits:
+  <pre class="brush: js">Before: 11100110111110100000000000000110000000000001
+After:              10100000000000000110000000000001</pre>
+ </li>
+ <li>Cada bit no primeiro operando é pareado com o bit correspondente no segundo operando: primeiro bit para o primeiro bit, segundo bit para o segundo bit e assim por diante.</li>
+ <li>O operador é aplicado para cada par de bits e o resultado é construído bit a bit.</li>
+</ul>
+
+<h3 id="(Bitwise_AND)"><a name="Bitwise_AND">&amp; (Bitwise AND)</a></h3>
+
+<p>Performa a operação AND em cada par de bits. <code>a</code> AND <code>b</code> retorna 1, apenas quando <code>a</code> e <code>b</code> são <code>1</code>. A tabela verdade para a operação AND é:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td class="header">a</td>
+   <td class="header">b</td>
+   <td class="header">a AND b</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+ </tbody>
+</table>
+
+<pre class="brush: js">.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 &amp; 9 (base 10) = 00000000000000000000000000001000 (base 2) = 8 (base 10)
+</pre>
+
+<p>Performar a operação AND bit-a-bit de qualquer número <code>x</code> com <code>0</code> retornará <code>0</code>. Performar a operação AND bit-a-bit de qualquer número <code>x</code> com <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">-1</span></font> retornará <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">x</span></font>.</p>
+
+<h3 id="(Bitwise_OR)"><a name="Bitwise_OR">| (Bitwise OR)</a></h3>
+
+<p>Performa a operação OR em cada par de bits. <code>a</code> OR <code>b</code> retorna 1 se pelo menos <code>a</code> ou pelo menos <code>b</code> é <code>1</code>. As tabela versão para a operação <code>OR</code> é:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td class="header">a</td>
+   <td class="header">b</td>
+   <td class="header">a OR b</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+ </tbody>
+</table>
+
+<pre class="brush: js">.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 | 9 (base 10) = 00000000000000000000000000001111 (base 2) = 15 (base 10)
+</pre>
+
+<p>Performar a operação <code>OR</code> de qulalquer número <code>x</code> com <code>0</code> retornará <code>0</code>. Performar a operação <code>OR</code> de qualquer número <code>X</code> com <code>-1</code> retornará <code>-1</code>.</p>
+
+<h3 id="(Bitwise_XOR)"><a name="Bitwise_XOR">^ (Bitwise XOR)</a></h3>
+
+<p>Performs the XOR operation on each pair of bits. <code>a</code> XOR <code>b</code> yields 1 if <code>a</code> and <code>b</code> are different. The truth table for the <code>XOR</code> operation is:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td class="header">a</td>
+   <td class="header">b</td>
+   <td class="header">a XOR b</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>0</td>
+  </tr>
+ </tbody>
+</table>
+
+<pre class="brush: js">.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
+</pre>
+
+<p>Bitwise XORing any number <code>x</code> with <code>0</code> yields x. Bitwise XORing any number <code>x</code> with <code>-1</code> yields <code>~x</code>.</p>
+
+<h3 id="(Bitwise_NOT)"><a name="Bitwise_NOT">~ (Bitwise NOT)</a></h3>
+
+<p>Performs the NOT operator on each bit. NOT <code>a</code> yields the inverted value (a.k.a. one's complement) of <code>a</code>. The truth table for the <code>NOT</code> operation is:</p>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <td class="header">a</td>
+   <td class="header">NOT a</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+  </tr>
+ </tbody>
+</table>
+
+<pre class="brush: js"> 9 (base 10) = 00000000000000000000000000001001 (base 2)
+               --------------------------------
+~9 (base 10) = 11111111111111111111111111110110 (base 2) = -10 (base 10)
+</pre>
+
+<p>Bitwise NOTing any number <code>x</code> yields <code>-(x + 1)</code>. For example, <code>~-5</code> yields <code>4</code>.</p>
+
+<p>Note that due to using 32-bit representation for numbers both <code>~-1</code> and <code>~4294967295</code> (2<sup>32</sup>-1) results in <code>0</code>.</p>
+
+<h2 id="Operadores_de_deslocamento_bit_a_bit">Operadores de deslocamento bit a bit</h2>
+
+<p>The bitwise shift operators take two operands: the first is a quantity to be shifted, and the second specifies the number of bit positions by which the first operand is to be shifted. The direction of the shift operation is controlled by the operator used.</p>
+
+<p>Shift operators convert their operands to 32-bit integers in big-endian order and return a result of the same type as the left operand. The right operand should be less than 32, but if not only the low five bits will be used.</p>
+
+<h3 id="&lt;&lt;_(Left_shift)"><a name="Left_shift">&lt;&lt; (Left shift)</a></h3>
+
+<p>This operator shifts the first operand the specified number of bits to the left. Excess bits shifted off to the left are discarded. Zero bits are shifted in from the right.</p>
+
+<p>For example, <code>9 &lt;&lt; 2</code> yields 36:</p>
+
+<pre class="brush: js">.    9 (base 10): 00000000000000000000000000001001 (base 2)
+                  --------------------------------
+9 &lt;&lt; 2 (base 10): 00000000000000000000000000100100 (base 2) = 36 (base 10)
+</pre>
+
+<p>Bitwise shifting any number <code>x</code> to the left by <code>y</code> bits yields <code>x * 2 ** y</code>.</p>
+
+<h3 id=">>_(Sign-propagating_right_shift)"><a name="Right_shift">&gt;&gt; (Sign-propagating right shift)</a></h3>
+
+<p>This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Copies of the leftmost bit are shifted in from the left. Since the new leftmost bit has the same value as the previous leftmost bit, the sign bit (the leftmost bit) does not change. Hence the name "sign-propagating".</p>
+
+<p>For example, <code>9 &gt;&gt; 2</code> yields 2:</p>
+
+<pre class="brush: js">.    9 (base 10): 00000000000000000000000000001001 (base 2)
+                  --------------------------------
+9 &gt;&gt; 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
+</pre>
+
+<p>Likewise, <code>-9 &gt;&gt; 2</code> yields <code>-3</code>, because the sign is preserved:</p>
+
+<pre class="brush: js">.    -9 (base 10): 11111111111111111111111111110111 (base 2)
+                   --------------------------------
+-9 &gt;&gt; 2 (base 10): 11111111111111111111111111111101 (base 2) = -3 (base 10)
+</pre>
+
+<h3 id=">>>_(Zero-fill_right_shift)"><a name="Unsigned_right_shift">&gt;&gt;&gt; (Zero-fill right shift)</a></h3>
+
+<p>This operator shifts the first operand the specified number of bits to the right. Excess bits shifted off to the right are discarded. Zero bits are shifted in from the left. The sign bit becomes 0, so the result is always non-negative.</p>
+
+<p>For non-negative numbers, zero-fill right shift and sign-propagating right shift yield the same result. For example, <code>9 &gt;&gt;&gt; 2</code> yields 2, the same as <code>9 &gt;&gt; 2</code>:</p>
+
+<pre class="brush: js">.     9 (base 10): 00000000000000000000000000001001 (base 2)
+                   --------------------------------
+9 &gt;&gt;&gt; 2 (base 10): 00000000000000000000000000000010 (base 2) = 2 (base 10)
+</pre>
+
+<p>However, this is not the case for negative numbers. For example, <code>-9 &gt;&gt;&gt; 2</code> yields 1073741821, which is different than <code>-9 &gt;&gt; 2</code> (which yields <code>-3</code>):</p>
+
+<pre class="brush: js">.     -9 (base 10): 11111111111111111111111111110111 (base 2)
+                    --------------------------------
+-9 &gt;&gt;&gt; 2 (base 10): 00111111111111111111111111111101 (base 2) = 1073741821 (base 10)
+</pre>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Flags_and_bitmasks">Flags and bitmasks</h3>
+
+<p>The bitwise logical operators are often used to create, manipulate, and read sequences of <em>flags</em>, which are like binary variables. Variables could be used instead of these sequences, but binary flags take much less memory (by a factor of 32).</p>
+
+<p>Suppose there are 4 flags:</p>
+
+<ul>
+ <li>flag A: we have an ant problem</li>
+ <li>flag B: we own a bat</li>
+ <li>flag C: we own a cat</li>
+ <li>flag D: we own a duck</li>
+</ul>
+
+<p>These flags are represented by a sequence of bits: DCBA. When a flag is <em>set</em>, it has a value of 1. When a flag is <em>cleared</em>, it has a value of 0. Suppose a variable <code>flags</code> has the binary value 0101:</p>
+
+<pre class="brush: js">var flags = 5;   // binary 0101
+</pre>
+
+<p>This value indicates:</p>
+
+<ul>
+ <li>flag A is true (we have an ant problem);</li>
+ <li>flag B is false (we don't own a bat);</li>
+ <li>flag C is true (we own a cat);</li>
+ <li>flag D is false (we don't own a duck);</li>
+</ul>
+
+<p>Since bitwise operators are 32-bit, 0101 is actually 00000000000000000000000000000101, but the preceding zeroes can be neglected since they contain no meaningful information.</p>
+
+<p>A <em>bitmask</em> is a sequence of bits that can manipulate and/or read flags. Typically, a "primitive" bitmask for each flag is defined:</p>
+
+<pre class="brush: js">var FLAG_A = 1; // 0001
+var FLAG_B = 2; // 0010
+var FLAG_C = 4; // 0100
+var FLAG_D = 8; // 1000
+</pre>
+
+<p>New bitmasks can be created by using the bitwise logical operators on these primitive bitmasks. For example, the bitmask 1011 can be created by ORing FLAG_A, FLAG_B, and FLAG_D:</p>
+
+<pre class="brush: js">var mask = FLAG_A | FLAG_B | FLAG_D; // 0001 | 0010 | 1000 =&gt; 1011
+</pre>
+
+<p>Individual flag values can be extracted by ANDing them with a bitmask, where each bit with the value of one will "extract" the corresponding flag. The bitmask <em>masks</em> out the non-relevant flags by ANDing with zeroes (hence the term "bitmask"). For example, the bitmask 0100 can be used to see if flag C is set:</p>
+
+<pre class="brush: js">// if we own a cat
+if (flags &amp; FLAG_C) { // 0101 &amp; 0100 =&gt; 0100 =&gt; true
+   // do stuff
+}
+</pre>
+
+<p>A bitmask with multiple set flags acts like an "either/or". For example, the following two are equivalent:</p>
+
+<pre class="brush: js">// if we own a bat or we own a cat
+// (0101 &amp; 0010) || (0101 &amp; 0100) =&gt; 0000 || 0100 =&gt; true
+if ((flags &amp; FLAG_B) || (flags &amp; FLAG_C)) {
+   // do stuff
+}
+</pre>
+
+<pre class="brush: js">// if we own a bat or cat
+var mask = FLAG_B | FLAG_C; // 0010 | 0100 =&gt; 0110
+if (flags &amp; mask) { // 0101 &amp; 0110 =&gt; 0100 =&gt; true
+   // do stuff
+}
+</pre>
+
+<p>Flags can be set by ORing them with a bitmask, where each bit with the value one will set the corresponding flag, if that flag isn't already set. For example, the bitmask 1100 can be used to set flags C and D:</p>
+
+<pre class="brush: js">// yes, we own a cat and a duck
+var mask = FLAG_C | FLAG_D; // 0100 | 1000 =&gt; 1100
+flags |= mask;   // 0101 | 1100 =&gt; 1101
+</pre>
+
+<p>Flags can be cleared by ANDing them with a bitmask, where each bit with the value zero will clear the corresponding flag, if it isn't already cleared. This bitmask can be created by NOTing primitive bitmasks. For example, the bitmask 1010 can be used to clear flags A and C:</p>
+
+<pre class="brush: js">// no, we don't have an ant problem or own a cat
+var mask = ~(FLAG_A | FLAG_C); // ~0101 =&gt; 1010
+flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
+</pre>
+
+<p>The mask could also have been created with <code>~FLAG_A &amp; ~FLAG_C</code> (De Morgan's law):</p>
+
+<pre class="brush: js">// no, we don't have an ant problem, and we don't own a cat
+var mask = ~FLAG_A &amp; ~FLAG_C;
+flags &amp;= mask;   // 1101 &amp; 1010 =&gt; 1000
+</pre>
+
+<p>Flags can be toggled by XORing them with a bitmask, where each bit with the value one will toggle the corresponding flag. For example, the bitmask 0110 can be used to toggle flags B and C:</p>
+
+<pre class="brush: js">// if we didn't have a bat, we have one now,
+// and if we did have one, bye-bye bat
+// same thing for cats
+var mask = FLAG_B | FLAG_C;
+flags = flags ^ mask;   // 1100 ^ 0110 =&gt; 1010
+</pre>
+
+<p>Finally, the flags can all be flipped with the NOT operator:</p>
+
+<pre class="brush: js">// entering parallel universe...
+flags = ~flags;    // ~1010 =&gt; 0101
+</pre>
+
+<h3 id="Conversion_snippets">Conversion snippets</h3>
+
+<p>Convert a binary <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> to a decimal <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code>:</p>
+
+<pre class="brush: js">var sBinString = '1011';
+var nMyNumber = parseInt(sBinString, 2);
+alert(nMyNumber); // prints 11, i.e. 1011
+</pre>
+
+<p>Convert a decimal <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code> to a binary <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code>:</p>
+
+<pre class="brush: js">var nMyNumber = 11;
+var sBinString = nMyNumber.toString(2);
+alert(sBinString); // prints 1011, i.e. 11
+</pre>
+
+<h3 id="Automate_Mask_Creation">Automate Mask Creation</h3>
+
+<p>You can create multiple masks from a set of <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Boolean</a></code> values, like this:</p>
+
+<pre class="brush: js">function createMask() {
+  var nMask = 0, nFlag = 0, nLen = arguments.length &gt; 32 ? 32 : arguments.length;
+  for (nFlag; nFlag &lt; nLen; nMask |= arguments[nFlag] &lt;&lt; nFlag++);
+  return nMask;
+}
+var mask1 = createMask(true, true, false, true); // 11, i.e.: 1011
+var mask2 = createMask(false, false, true); // 4, i.e.: 0100
+var mask3 = createMask(true); // 1, i.e.: 0001
+// etc.
+
+alert(mask1); // prints 11, i.e.: 1011
+</pre>
+
+<h3 id="Reverse_algorithm_an_array_of_booleans_from_a_mask">Reverse algorithm: an array of booleans from a mask</h3>
+
+<p>If you want to create an <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> of <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code> from a mask you can use this code:</p>
+
+<pre class="brush: js">function arrayFromMask(nMask) {
+  // nMask must be between -2147483648 and 2147483647
+  if (nMask &gt; 0x7fffffff || nMask &lt; -0x80000000) {
+    throw new TypeError('arrayFromMask - out of range');
+  }
+  for (var nShifted = nMask, aFromMask = []; nShifted;
+       aFromMask.push(Boolean(nShifted &amp; 1)), nShifted &gt;&gt;&gt;= 1);
+  return aFromMask;
+}
+
+var array1 = arrayFromMask(11);
+var array2 = arrayFromMask(4);
+var array3 = arrayFromMask(1);
+
+alert('[' + array1.join(', ') + ']');
+// prints "[true, true, false, true]", i.e.: 11, i.e.: 1011
+</pre>
+
+<p>You can test both algorithms at the same time…</p>
+
+<pre class="brush: js">var nTest = 19; // our custom mask
+var nResult = createMask.apply(this, arrayFromMask(nTest));
+
+alert(nResult); // 19
+</pre>
+
+<p>For the didactic purpose only (since there is the <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toString" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number/toString">Number.toString(2)</a></code> method), we show how it is possible to modify the <code>arrayFromMask</code> algorithm in order to create a <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String" title="/en-US/docs/JavaScript/Reference/Global_Objects/String">String</a></code> containing the binary representation of a <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/JavaScript/Reference/Global_Objects/Number">Number</a></code>, rather than an <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array" title="/en-US/docs/JavaScript/Reference/Global_Objects/Array">Array</a></code> of <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="/en-US/docs/JavaScript/Reference/Global_Objects/Boolean">Booleans</a></code>:</p>
+
+<pre class="brush: js">function createBinaryString(nMask) {
+  // nMask must be between -2147483648 and 2147483647
+  for (var nFlag = 0, nShifted = nMask, sMask = ''; nFlag &lt; 32;
+       nFlag++, sMask += String(nShifted &gt;&gt;&gt; 31), nShifted &lt;&lt;= 1);
+  return sMask;
+}
+
+var string1 = createBinaryString(11);
+var string2 = createBinaryString(4);
+var string3 = createBinaryString(1);
+
+alert(string1);
+// prints 00000000000000000000000000001011, i.e. 11
+</pre>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.7')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.4.8">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.7">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.10">Binary bitwise operators</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-bitwise-shift-operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-binary-bitwise-operators">Binary bitwise operators</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-bitwise-shift-operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Defined in several sections of the specification: <a href="http://tc39.github.io/ecma262/#sec-bitwise-not-operator">Bitwise NOT operator</a>, <a href="http://tc39.github.io/ecma262/#sec-bitwise-shift-operators">Bitwise shift operators</a>, <a href="http://tc39.github.io/ecma262/#sec-binary-bitwise-operators">Binary bitwise operators</a></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility">Browser compatibility</h2>
+
+<div class="hidden">
+<p>The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
+</div>
+
+<p>{{Compat("javascript.operators.bitwise")}}</p>
+
+<h2 id="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators">Logical operators</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/bitwise_xor/index.html b/files/pt-br/web/javascript/reference/operators/bitwise_xor/index.html
new file mode 100644
index 0000000000..9a8fe88d4c
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/bitwise_xor/index.html
@@ -0,0 +1,108 @@
+---
+title: Bitwise XOR (^)
+slug: Web/JavaScript/Reference/Operators/Bitwise_XOR
+translation_of: Web/JavaScript/Reference/Operators/Bitwise_XOR
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>O operador bitwise XOR (<code>^</code>) retorna o numero 1 em cada posição de bit para a qual os bits correspondentes de ambos, mas não de ambos os operandos, são <code>1</code>s.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-bitwise-xor.html")}}</div>
+
+<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><code><var>a</var> ^ <var>b</var></code>
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Os operandos são convertidos em números inteiros de 32 bits e expressados por uma série de bits (zeros e uns). Numeros com mais de 32 bits descartam seus bits mais significativos. Por exemplo, o número inteiro a seguir com mais de 32 bits será convertido em um número inteiro de 32 bits:</p>
+
+<pre class="brush: js notranslate">Antes: 11100110111110100000000000000110000000000001
+Depois:            10100000000000000110000000000001</pre>
+
+<p>Cada bit no primeiro operando é emparelhado com o bit correspondente no segundo operando: primeiro bit para o primeiro bit, segundo bit para o segundo bit e assim por diante.</p>
+
+<p>O operador é aplicado para cada par de bits e o resultado é construído em bitwise.</p>
+
+<p>A tabela verdade para a operação XOR é:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th class="header" scope="col">a</th>
+   <th class="header" scope="col">b</th>
+   <th class="header" scope="col">a XOR b</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>0</td>
+   <td>0</td>
+   <td>0</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>0</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>1</td>
+   <td>0</td>
+  </tr>
+ </tbody>
+</table>
+
+<pre class="brush: js notranslate">.    9 (base 10) = 00000000000000000000000000001001 (base 2)
+    14 (base 10) = 00000000000000000000000000001110 (base 2)
+                   --------------------------------
+14 ^ 9 (base 10) = 00000000000000000000000000000111 (base 2) = 7 (base 10)
+</pre>
+
+<p>Bitwise XORing any number <code><var>x</var></code> with <code>0</code> yields <code><var>x</var></code>.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_bitwise_XOR">Usando bitwise XOR</h3>
+
+<pre class="brush: js notranslate">// 9  (00000000000000000000000000001001)
+// 14 (00000000000000000000000000001110)
+
+14 ^ 9;
+// 7  (00000000000000000000000000000111)</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#prod-BitwiseXORExpression', 'Bitwise XOR expression')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_Navegador">Compatibilidade do Navegador</h2>
+
+<div class="hidden">The compatibility table on this page is generated from structured data. If you'd like to contribute to the data, please check out <a class="external" href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</div>
+
+<p>{{Compat("javascript.operators.bitwise_xor")}}</p>
+
+<h2 id="Leia_também">Leia também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Bitwise">Bitwise operators in the JS guide</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_XOR_assignment">Bitwise XOR assignment operator</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/class/index.html b/files/pt-br/web/javascript/reference/operators/class/index.html
new file mode 100644
index 0000000000..defeeff680
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/class/index.html
@@ -0,0 +1,173 @@
+---
+title: class expression
+slug: Web/JavaScript/Reference/Operators/class
+tags:
+  - Classes
+  - ECMAScript 2015
+  - Expression
+  - Expressão
+  - Operador
+  - Operator
+  - Reference
+  - Referencia
+translation_of: Web/JavaScript/Reference/Operators/class
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>A <strong>expressão class</strong> é uma das formas de definir uma classe no ECMAScript 2015. Parecido com as <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">expressões function</a>, expressões class poder ser nomeadas ou não. Se nomeada, o nome da classe é local para apenas o corpo da classe. Classes no JavaScript usam herança com base no prototype</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">var MinhaClasse = class <em>[nomeDaClass]</em> [extends] {
+  // corpo da classe
+};</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Uma expressão de classe tem uma sintaxe similar a uma <a href="/en-US/docs/Web/JavaScript/Reference/Statements/class">declaração de classe</a>. No entanto, com expressões de classe, você poderá omitir o nome da classe ("ligação de identificadores"), que você não pode se usar declarações. Adicionalmente, expressões de classe permitem que você redefina/redeclare classes e <strong>não invocar</strong> nenhum tipo de erros como <a href="/en-US/docs/Web/JavaScript/Reference/Statements/class">declaração de classe</a>. A propriedade construtora é opcional. E o <em>typeof </em>de classes geradas usando essa palavra-chave sempre será "function".</p>
+
+<p>Assim como declarações de classes, o corpo das expressões de classe são executados em <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>.</p>
+
+<pre class="brush: js">'use strict';
+var Foo = class {}; // propriedade de construtor é opcional
+var Foo = class {}; // Re-declaração é permitida
+
+typeof Foo; //returna "function"
+typeof class {}; //returna "function"
+
+Foo instanceof Object; // true
+Foo instanceof Function; // true
+class Foo {}; // Throws TypeError, não permite re-declaração
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Uma_simples_expressão_de_classe">Uma simples expressão de classe</h3>
+
+<p>Isso é apenas uma simples classe anônima que você pode referir usando a variável "Foo".</p>
+
+<pre class="brush: js">var Foo = class {
+  constructor() {}
+  bar() {
+    return 'Olá mundo!';
+  }
+};
+
+var instance = new Foo();
+instance.bar(); // "Olá mundo!"
+Foo.name; // "Foo"
+</pre>
+
+<h3 id="Expressões_de_classes_nomeadas">Expressões de classes nomeadas</h3>
+
+<p>Se você quiser referir a classe atual dentro do corpo da classe, você pode criar uma expressão de classe nomeada. Esse nome é visível apenas no escopo da expressão classe sozinha.</p>
+
+<pre class="brush: js">var Foo = class NamedFoo {
+  constructor() {}
+  whoIsThere() {
+    return NamedFoo.name;
+  }
+}
+var bar = new Foo();
+bar.whoIsThere(); // "NamedFoo"
+NamedFoo.name; // ReferenceError: NamedFoo is not defined
+Foo.name; // "NamedFoo"
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-class-definitions', 'Class definitions')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2016', '#sec-class-definitions', 'Class definitions')}}</td>
+   <td>{{Spec2('ES2016')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2017', '#sec-class-definitions', 'Class definitions')}}</td>
+   <td>{{Spec2('ES2017')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-class-definitions', 'Class definitions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_inicial">Compatibilidade inicial</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop(45)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile(45)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatChrome(42.0)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">Expressão <code>function</code> </a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/class">Declaração <code>class</code> </a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/expression_closures/index.html b/files/pt-br/web/javascript/reference/operators/expression_closures/index.html
new file mode 100644
index 0000000000..afae2c0459
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/expression_closures/index.html
@@ -0,0 +1,72 @@
+---
+title: Expression closures
+slug: Web/JavaScript/Reference/Operators/Expression_closures
+translation_of: Archive/Web/JavaScript/Expression_closures
+---
+<div>{{JSSidebar("Operators")}}{{Non-standard_Header}}{{Obsolete_Header("gecko60")}}
+<div class="warning"><strong>Não padronizado. Não use!</strong><br>
+A síntaxe expressão closure syntax é uma feature especifica ao Firefox que foi deprecada e foi removida a partir do Firefox 60. Para usos futuros considere usar <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a>.</div>
+</div>
+
+<p>Expressões fechamentos são uma  forma curta de sintaxe de função para escrever funções simples.</p>
+
+<h2 id="Síntaxe">Síntaxe</h2>
+
+<pre class="syntaxbox">function [<em>nome</em>]([<em>param1</em>[, <em>param2[</em>, ..., <em>paramN</em>]]])
+   <em>expressão</em>
+</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>nome</code></dt>
+ <dd>O nome da função. Pode ser omitido, passando a ser nesse caso uma função <em>anónima</em>. O nome só é local ao corpo da função.</dd>
+ <dt><code>paramN</code></dt>
+ <dd>Nome do parâmetro a ser passado à função. Uma função pode receber até 255 argumentos.</dd>
+ <dt><code>expressão</code></dt>
+ <dd>A expressão pela qual o corpo da função é composta</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Esta adição é nada mais que uma maneira reduzida de escreve funções simples, dando à linguagem algo semelhante a <a class="external" href="http://en.wikipedia.org/wiki/Lambda_calculus#Lambda_calculus_and_programming_languages">Notação Lambda</a>.</p>
+
+<p>JavaScript 1.7 e anterior:</p>
+
+<pre class="brush: js">function(x) { return x * x; }</pre>
+
+<p>JavaScript 1.8:</p>
+
+<pre class="brush: js">function(x) x * x</pre>
+
+<p>Esta Síntaxe permite omitir as chavetas e o 'return' - fazendo-os implícitos. Não benifício adicional em escrever código desta forma para além de ser sintáticamente reduzido.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>Uma maneira reduzida de fazer bind de EventListeners:</p>
+
+<pre class="brush: js"> document.addEventListener('click', function() false, true);
+</pre>
+
+<p>Usando esta função com algumas funções de array do JavaScript 1.6:</p>
+
+<pre class="brush: js">elems.some(function(elem) elem.type == 'text');
+</pre>
+
+<h2 id="Compatibilidade_do_Browser">Compatibilidade do Browser</h2>
+
+
+
+<p>{{Compat("javascript.operators.expression_closures")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li>{{JSxRef("Functions_and_function_scope", "Functions and function scope")}}</li>
+ <li>{{JSxRef("Function")}}</li>
+ <li>{{JSxRef("Statements/function", "function statement")}}</li>
+ <li>{{JSxRef("Operators/function", "function expression")}}</li>
+ <li>{{JSxRef("Statements/function*", "function* statement")}}</li>
+ <li>{{JSxRef("Operators/function*", "function* expression")}}</li>
+ <li>{{JSxRef("GeneratorFunction")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/function/index.html b/files/pt-br/web/javascript/reference/operators/function/index.html
new file mode 100644
index 0000000000..a5950f8ea1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/function/index.html
@@ -0,0 +1,113 @@
+---
+title: Expressão de função (function expression)
+slug: Web/JavaScript/Reference/Operators/function
+tags:
+  - Expressões Primárias
+  - Função
+  - Internet
+  - JavaScript
+  - Operador
+  - Rede
+  - Web
+translation_of: Web/JavaScript/Reference/Operators/function
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>A palavara-chave <strong><code>function</code></strong> pode ser usada para definir uma função dentro de uma expressão.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">function [<em>name</em>]([<em>param1</em>[, <em>param2[</em>, ..., <em>paramN</em>]]]) {
+   <em>statements</em>
+}</pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>name</code></dt>
+ <dd>O nome da função. Pode ser omitido, neste caso a função será anônima. O nome só é local em relação ao corpo da função. </dd>
+ <dt><code>paramN</code></dt>
+ <dd>O nome de um argumento a ser passado para a função.</dd>
+ <dt><code>statements</code></dt>
+ <dd>As declarações que compreendem o corpo da função.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Uma expressão de função (<em>function expression</em>) é muito similar e tem quase a mesma sintaxe de uma declaração de função (veja <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a> para mais detalhes). A principal diferença entre uma expressão de função e a declaração de uma função é o nome da função (<em>function name</em>)<em>,</em> o qual pode ser omitido em expressões de funções para criar funções anônimas. Veja ainda o capítulo sobre <a href="/en-US/docs/Web/JavaScript/Reference/Functions">funções</a> para maiores informações.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>O exemplo a seguir define uma função sem nome e a atribui a x. A função retorna o quadrado de seu argumento:</p>
+
+<pre class="brush: js">var x = function(y) {
+   return y * y;
+};
+</pre>
+
+<h3 id="Expressão_de_função_nomeada">Expressão de função nomeada</h3>
+
+<p>Se você quer se referir à função atual dentro do corpo da função, você terá que criar uma expressão de função nomeada. Este nome será local apenas para o corpo (escopo) da função. Isto ainda evita o uso da propriedade não-padronizada <code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments/callee">arguments.callee</a></code>.</p>
+
+<pre class="brush: js">var math = {
+  'factorial': function factorial(n) {
+    if (n &lt;= 1)
+      return 1;
+    return n * factorial(n - 1);
+  }
+};
+</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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-13', 'Function definition')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-13', 'Function definition')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.5.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegador">Compatibilidade de Navegador</h2>
+
+<div class="hidden">
+<p>A tabela de compatibilidade nesta página é gerada por dados estruturados.<br>
+ Se você quiser contribuir para com os dados, por favor, veja <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande um <em>pull request</em>.</p>
+</div>
+
+<p>{{CompatibilityTable}}</p>
+
+<p>{{Compat("javascript.operators.function")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Functions_and_function_scope", "Funções e Escopos de Funções")}}</li>
+ <li>{{jsxref("Função")}}</li>
+ <li>{{jsxref("Statements/function", "function statement")}}</li>
+ <li>{{jsxref("Statements/function*", "function* statement")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("GeneratorFunction")}}<span style='background-color: #ffffff; color: #333333; display: inline !important; float: none; font-family: "Open Sans",arial,x-locale-body,sans-serif; font-size: 12px; font-style: normal; font-variant: normal; font-weight: 400; letter-spacing: normal; text-align: left; text-decoration: none; text-indent: 0px; text-transform: none; white-space: normal; word-wrap: break-word;'>VersãoCompatívelDesconhecida<span style='background-color: #ffffff; color: #333333; display: inline !important; float: none; font-family: "Open Sans",arial,x-locale-body,sans-serif; font-size: 12px; font-style: normal; font-variant: normal; font-weight: 400; letter-spacing: normal; text-align: left; text-decoration: none; text-indent: 0px; text-transform: none; white-space: normal; word-wrap: break-word;'>VersãoCompatívelDesconhecida</span></span></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/function_star_/index.html b/files/pt-br/web/javascript/reference/operators/function_star_/index.html
new file mode 100644
index 0000000000..66d9975558
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/function_star_/index.html
@@ -0,0 +1,167 @@
+---
+title: Expressão function*
+slug: Web/JavaScript/Reference/Operators/function*
+translation_of: Web/JavaScript/Reference/Operators/function*
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>A palavra-chave <strong><code>function*</code></strong> pode ser usada para definir uma função generator dentro de uma expressão.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">function* [<em>nome</em>]([<em>param1</em>[, <em>param2[</em>, ..., <em>paramN</em>]]]) {
+    <em>declarações</em>
+}</pre>
+
+<dl>
+ <dt><code>nome</code></dt>
+ <dd>O nome da função. Pode ser omitido, no caso da função ser anônima. O nome é local apenas para o corpo da função.</dd>
+ <dt><code>paramN</code></dt>
+ <dd>O nome de um argumento para ser passado para a função. Uma função pode ter até 255 argumentos.</dd>
+ <dt><code>declarações</code></dt>
+ <dd>As declarações que compõem o corpo da função.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Uma expressão <code>function*</code> é muito similar e tem quase a mesma sintaxe que a {{jsxref('Statements/function*', 'declaração function*')}}. A principal diferença entre uma expressão  <code>function*</code> e a declaração <code>function*</code> é o <em>nome da função</em>, que pode ser omitido em expressões <code>function*</code> para criar funções <em>anônimas</em>. Veja também o capítulo sobre <a href="/en-US/docs/Web/JavaScript/Reference/Functions">funções</a> para mais informações.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>O exemplo a seguir define uma função generator e atribui à variável <code>x</code>. A função faz um yield do quadrado do seu argumento:</p>
+
+<pre class="brush: js">var x = function*(y) {
+   yield y * y;
+};
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#', 'function*')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#', 'function*')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("26.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+  <tr>
+   <td><code>yield*</code></td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("27.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+  <tr>
+   <td>Trailing comma in parameters</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("52.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("26.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+  <tr>
+   <td><code>yield*</code></td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("27.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+  <tr>
+   <td>Trailing comma in parameters</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("52.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/function*", "function* statement")}}</li>
+ <li>{{jsxref("GeneratorFunction")}} object</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li>
+ <li>{{jsxref("Operators/yield", "yield")}}</li>
+ <li>{{jsxref("Operators/yield*", "yield*")}}</li>
+ <li>{{jsxref("Function")}} object</li>
+ <li>{{jsxref("Statements/function", "function statement")}}</li>
+ <li>{{jsxref("Operators/function", "function expression")}}</li>
+ <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/generator_comprehensions/index.html b/files/pt-br/web/javascript/reference/operators/generator_comprehensions/index.html
new file mode 100644
index 0000000000..1cbfb286f4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/generator_comprehensions/index.html
@@ -0,0 +1,169 @@
+---
+title: Generator comprehensions
+slug: Web/JavaScript/Reference/Operators/Generator_comprehensions
+translation_of: Archive/Web/JavaScript/Generator_comprehensions
+---
+<div>{{JSSidebar("Operators")}}{{Non-standard_Header}}{{Obsolete_Header("gecko58")}}
+<div class="blockIndicator warning">
+<p><strong>Não padronizado. Não use!</strong><br>
+ A sintaxe de generator comprehensions não é padronizada e foi removida a partir do Firefox 58. Para usos futuros, considere o uso de {{JSxRef ("Statements / function *", "generator", "", 1)}}.</p>
+</div>
+</div>
+
+<p>A sintaxe de <strong>generator comprehension</strong> foi uma expressão em JavaScript que permitia montar rapidamente um nova função geradora baseada em um objeto iterável existente. Porém, ela foi removida do padrão e da implementação Firefox. Não a use!</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">(for (x of iterable) x)
+(for (x of iterable) if (condition) x)
+(for (x of iterable) for (y of iterable) x + y)
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Dentro de generator comprehensions, são permitidos dois tipos de componentes:</p>
+
+<ul>
+ <li>{{JSxRef("Statements/for...of", "for...of")}} and</li>
+ <li>{{JSxRef("Statements/if...else", "if")}}</li>
+</ul>
+
+<p>A iteração <code>for-of</code> é sempre o primeiro componente. Várias iterações <code>for-of</code> or declarações <code>if</code> são permitidas.</p>
+
+<p>Uma desvantagem significativa das {{JSxRef("Operators/Array_comprehensions","array comprehensions","","true")}} é que elas causam a construção de um array inteiro na memória. Quando a entrada para a comprehension é em si um pequeno array ,a sobrecarga envolvida é insignificante — mas quando a entrada é um grande array ou um generator custoso (ou mesmo infinito), a criação de um novo array pode ser problemática.</p>
+
+<p>Geradores permitem o cálculo lento de sequências, com items calculados sob demanda conforme a necessidade. Generator comprehensions são sintaticamente quase idênticos aos array comprehensions — elas usam parênteses invés de chaves — mas invés de construir um array, criam um gerador que pode executar lentamente. Eles podem ser considerados como uma sintaxe abreviada para criar geradores</p>
+
+<p>Suponha que temos um interador <code>it</code> que itera sobre uma grande sequência de inteiros. Queremos criar um novo iterador que irá iterar sobre seus dobros. Um array comprehension criaria na memória um array completo contendo os valores dobrados:</p>
+
+<pre class="brush: js">var doubles = [for (i in it) i * 2];
+</pre>
+
+<p>Um generator comprehension por outro lado criaria um novo iterador que criaria valores dobrados sob demanda conforme a necessidade:</p>
+
+<pre class="brush: js">var it2 = (for (i in it) i * 2);
+console.log(it2.next()); // O primeiro valor, duplicado
+console.log(it2.next()); // O segundo valor, duplicado
+</pre>
+
+<p>Quando um generator comprehension é usado como um argumento para uma função, os parênteses usados para a chamada da função significam que os parênteses externos podem ser omitidos:</p>
+
+<pre class="brush: js">var result = doSomething(for (i in it) i * 2);
+</pre>
+
+<p>A diferença significativa entre os dois exemplos começam pelo uso da generator comprehension, você teria apenas que fazer um loop sobre a estrutura 'obj' uma vez, total, ao invés de uma vez ao compreender o array, e mais uma vez ao iterar sobre ele.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Simples_generator_comprehensions">Simples generator comprehensions</h3>
+
+<pre class="brush:js">(for (i of [1, 2, 3]) i * i );
+// generator function which yields 1, 4, and 9
+
+[...(for (i of [1, 2, 3]) i * i )];
+// [1, 4, 9]
+
+var abc = ['A', 'B', 'C'];
+(for (letters of abc) letters.toLowerCase());
+// generator function which yields "a", "b", and "c"
+</pre>
+
+<h3 id="Generator_comprehensions_com_declaração_if">Generator comprehensions com declaração if</h3>
+
+<pre class="brush: js">var years = [1954, 1974, 1990, 2006, 2010, 2014];
+
+(for (year of years) if (year &gt; 2000) year);
+// generator function which yields 2006, 2010, and 2014
+
+(for (year of years) if (year &gt; 2000) if (year &lt; 2010) year);
+// generator function which yields 2006, the same as below:
+
+(for (year of years) if (year &gt; 2000 &amp;&amp; year &lt; 2010) year);
+// generator function which yields 2006
+</pre>
+
+<h3 id="Generator_comprehensions_comparadas_à_função_geradora">Generator comprehensions comparadas à função geradora</h3>
+
+<p>Um maneira fácil de entender a sintaxe de generator comprehension, é compará-la com a função geradora.</p>
+
+<p>Exemplo 1: Gerador simples.</p>
+
+<pre class="brush: js">var numbers = [1, 2, 3];
+
+// Generator function
+(function*() {
+  for (let i of numbers) {
+    yield i * i;
+  }
+})();
+
+// Generator comprehension
+(for (i of numbers) i * i );
+
+// Result: both return a generator which yields [1, 4, 9]
+</pre>
+
+<p>Exemplo 2: Usando <code>if</code> no gerador.</p>
+
+<pre class="brush: js">var numbers = [1, 2, 3];
+
+// Generator function
+(function*() {
+  for (let i of numbers) {
+    if (i &lt; 3) {
+      yield i * 1;
+    }
+  }
+})();
+
+// Generator comprehension
+(for (i of numbers) if (i &lt; 3) i);
+
+// Result: both return a generator which yields [1, 2]</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p>As generator comprehensions estavam inicialmente no rascunho do ECMAScript 2015, mas foram removidas na revisão 27 (agosto de 2014). Por favor, veja as revisões mais antigas do ES2015 para a semântica de especificação.</p>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você quiser contribuir com os dados, confira https://github.com/mdn/browser-compat-data e envie-nos uma solicitação de recebimento.</div>
+
+<p>{{Compat("javascript.operators.generator_comprehensions")}}</p>
+
+<h2 id="Diferenças_para_as_antigas_JS1.7JS1.8_comprehensions">Diferenças para as antigas JS1.7/JS1.8 comprehensions</h2>
+
+<div class="blockIndicator warning">Comprehensions das versões JS1.7/JS1.8 foram removidas da Gecko 46 ({{bug(1220564)}}).</div>
+
+<p><strong>Sintaxe antiga das </strong><strong>comprehensions (não use mais!):</strong></p>
+
+<pre class="brush: js example-bad">(X for (Y in Z))
+(X for each (Y in Z))
+(X for (Y of Z))
+</pre>
+
+<p>Diferenças:</p>
+
+<ul>
+ <li>Comprehensions na ES7 criam um escopo para cada nó "for" invés da comprehension como um todo.
+  <ul>
+   <li>Antiga: <code>[...(()=&gt;x for (x of [0, 1, 2]))][1]() // 2</code></li>
+   <li>Nova: <code>[...(for (x of [0, 1, 2]) ()=&gt;x)][1]() // 1, cada iteração cria uma nova ligação para x</code><code>. </code></li>
+  </ul>
+ </li>
+ <li>Comprehensions na ES7 começam com "for" invés da expressão de atribuição.
+  <ul>
+   <li>Antiga: <code>(i * 2 for (i of numbers))</code></li>
+   <li>Nova: <code>(for (i of numbers) i * 2)</code></li>
+  </ul>
+ </li>
+ <li>Comprehensions na ES7 podem ter vários componentes <code>if</code> e <code>for</code>.</li>
+ <li>Comprehensions na ES7 apenas trabalham com <code>{{JSxRef("Statements/for...of", "for...of")}}</code> e não com iterações <code>{{JSxRef("Statements/for...in", "for...in")}}</code>.</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{JSxRef("Statements/for...of", "for...of")}}</li>
+ <li>{{JSxRef("Operators/Array_comprehensions", "Array comprehensions")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/grouping/index.html b/files/pt-br/web/javascript/reference/operators/grouping/index.html
new file mode 100644
index 0000000000..56e11538d2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/grouping/index.html
@@ -0,0 +1,114 @@
+---
+title: Operador de Agrupamento
+slug: Web/JavaScript/Reference/Operators/Grouping
+tags:
+  - Expressões Primárias
+  - JavaScript
+  - Operadores
+translation_of: Web/JavaScript/Reference/Operators/Grouping
+---
+<div>
+ {{jsSidebar("Operators")}}</div>
+<h2 id="Sumário">Sumário</h2>
+<p><span class="seoSummary">O operador de agrupamento <code>()</code> controla a precedência e a precedência de avaliação em expressões.</span></p>
+<h2 id="Sintaxe">Sintaxe</h2>
+<pre class="syntaxbox"> ( )</pre>
+<h2 id="Descrição">Descrição</h2>
+<p>O operador de agrupamento consiste em um par de parênteses em volta de uma expressão, ou sub-expressão, para ignorar a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">precedência normal de operadores</a> de modo que expressões com menor precedência possam ser avaliadas antes de uma expressão com maior prioridade.</p>
+<h2 id="Exemplos">Exemplos</h2>
+<p>Ignorando multiplicação e divisão primeiro, então adição e substração para avarliar adição primeiramente.</p>
+<pre class="brush:js">var a = 1;
+var b = 2;
+var c = 3;
+
+// default precedence
+a + b * c     // 7
+// evaluated by default like this
+a + (b * c)   // 7
+
+// now overriding precedence
+// addition before multiplication
+(a + b) * c   // 9
+
+// which is equivalent to
+a * c + b * c // 9
+</pre>
+<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>Primeira definição. Implementado no JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.1.6', 'The Grouping Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-grouping-operator', 'The Grouping Operator')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+<h2 id="Compatibilidade">Compatibilidade</h2>
+<p>{{ CompatibilityTable() }}</p>
+<div id="compat-desktop">
+ <table class="compat-table">
+  <tbody>
+   <tr>
+    <th>Feature</th>
+    <th>Chrome</th>
+    <th>Firefox (Gecko)</th>
+    <th>Internet Explorer</th>
+    <th>Opera</th>
+    <th>Safari</th>
+   </tr>
+   <tr>
+    <td>Basic support</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+   </tr>
+  </tbody>
+ </table>
+</div>
+<div id="compat-mobile">
+ <table class="compat-table">
+  <tbody>
+   <tr>
+    <th>Feature</th>
+    <th>Android</th>
+    <th>Chrome for Android</th>
+    <th>Firefox Mobile (Gecko)</th>
+    <th>IE Mobile</th>
+    <th>Opera Mobile</th>
+    <th>Safari Mobile</th>
+   </tr>
+   <tr>
+    <td>Basic support</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+   </tr>
+  </tbody>
+ </table>
+</div>
+<h2 id="See_also" name="See_also">Veja também</h2>
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Operator precedence</a></li>
+ <li>{{jsxref("Operators/delete", "delete")}}</li>
+ <li>{{jsxref("Operators/typeof", "typeof")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/in/index.html b/files/pt-br/web/javascript/reference/operators/in/index.html
new file mode 100644
index 0000000000..ebda32f1ab
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/in/index.html
@@ -0,0 +1,137 @@
+---
+title: in operator
+slug: Web/JavaScript/Reference/Operators/in
+translation_of: Web/JavaScript/Reference/Operators/in
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>O <strong>operador</strong> <strong><code>in</code> </strong>retorna  <code>true</code> se a propriedade especificada estiver no objeto especificado ou na sua cadeia de protótipo (prototype chain) desde objeto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><em>prop</em> in <em>object</em></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>prop</code></dt>
+ <dd>Um string ou símbolo representando o nome de uma propriedade ou o índice de um array (não-símbolos serão trazidos para strings).</dd>
+</dl>
+
+<dl>
+ <dt><code>object</code></dt>
+ <dd>Objeto para verificar se este (ou sua cadeia de protótipo) contém a propriedade com o nome especificado.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Os exemplos a seguir mostram alguns usos do operador <code>in</code>.</p>
+
+<pre class="brush:js">// Arrays
+var trees = ['redwood', 'bay', 'cedar', 'oak', 'maple'];
+0 in trees        // retorna true
+3 in trees        // retorna true
+6 in trees        // retorna false
+'bay' in trees    // retorna false (você precisa especificar o
+                  // número do índice, não o valor naquele índice)
+'length' in trees // retorna true (length é uma propridade do Array)
+Symbol.iterator in trees // retorna true (arrays são iteráveis, funciona apenas na ES2015+)
+
+// Objetos predefinidos
+'PI' in Math          // retorna true
+
+// Objetos personalizados
+var mycar = {make: 'Honda', model: 'Accord', year: 1998};
+'make' in mycar  // retorna true
+'model' in mycar // retorna true
+</pre>
+
+<p>Você precisa especificar um objeto no lado direito do operador <code>in</code>. Por exemplo, você pode especifica um string criado com o construtor <code>String,</code> mas você não pode especificar um string literal.</p>
+
+<pre class="brush:js">var color1 = new String('green');
+'length' in color1 // retorna true
+
+var color2 = 'coral';
+// gera um erro (color2 não é um objeto String)
+'length' in color2
+</pre>
+
+<h3 id="Usando_in_com_propriedade_removida_ou_undefined">Usando <code>in</code> com propriedade removida ou undefined</h3>
+
+<p>Se você remover uma propriedade com o operador <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code> , o operador <code>in</code> retorna <code>false</code> para essa propriedade.</p>
+
+<pre class="brush:js">var mycar = {make: 'Honda', model: 'Accord', year: 1998};
+delete mycar.make;
+'make' in mycar;  // retorna false
+
+var trees = new Array('redwood', 'bay', 'cedar', 'oak', 'maple');
+delete trees[3];
+3 in trees; // retorna false
+</pre>
+
+<p>Se você definir uma propriedade como {{jsxref("Global_Objects/undefined", "undefined")}}, mas não a remover, o operador <code>in</code> retorna <code>true</code> para essa propriedade.</p>
+
+<pre class="brush:js">var mycar = {make: 'Honda', model: 'Accord', year: 1998};
+mycar.make = undefined;
+'make' in mycar;  // retorna true
+</pre>
+
+<pre class="brush:js">var trees = new Array('redwood', 'bay', 'cedar', 'oak', 'maple');
+trees[3] = undefined;
+3 in trees; // retorna true
+</pre>
+
+<h3 id="Propriedades_herdadas">Propriedades herdadas</h3>
+
+<p>O operador <code>in</code> retorna <code>true</code> para propriedades que estão na cadeida de protótipo (prototype chain).</p>
+
+<pre class="brush:js">'toString' in {}; // retorna true
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-relational-operators', 'Relational Operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-relational-operators', 'Relational Operators')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.8.7', 'The in Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-11.8.7', 'The in Operator')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.4.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+
+
+<p>{{Compat("javascript.operators.in")}}</p>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></code></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete</a></code></li>
+ <li>{{jsxref("Object.prototype.hasOwnProperty()")}}</li>
+ <li>{{jsxref("Reflect.has()")}}</li>
+ <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/index.html b/files/pt-br/web/javascript/reference/operators/index.html
new file mode 100644
index 0000000000..aad3be45b6
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/index.html
@@ -0,0 +1,281 @@
+---
+title: Operadores
+slug: Web/JavaScript/Reference/Operators
+tags:
+  - NeedsTranslation
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Operators
+---
+<div>{{jsSidebar("Operadores")}}</div>
+
+<p>Este capítulo documenta todos os operadores, expressões e keywords da linguagem JavaScript .</p>
+
+<h2 id="Expressões_e_operadores_por_categoria">Expressões e operadores por categoria</h2>
+
+<p>Para uma lista alfabética ver a barra lateral à esquerda.</p>
+
+<h3 id="Expressões_primárias">Expressões primárias</h3>
+
+<p>Palavras-chave e expressões básicas em JavaScript.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/this", "this")}}</dt>
+ <dd>A palavra-chave <code>this</code> refere-se ao contexto de execução da função.</dd>
+ <dt>{{jsxref("Operators/function", "function")}}</dt>
+ <dd>A palavra-chave <code>function</code> define uma função.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operators/class", "class")}}</dt>
+ <dd>A palavra-chave <code>class</code> define uma classe.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operators/function*", "function*")}}</dt>
+ <dd>A palavra-chave <code>function*</code>  define um gerador de função.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operators/yield", "yield")}}</dt>
+ <dd>Pausa e retorma uma função de gerador</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operators/yield*", "yield*")}}</dt>
+ <dd>Delegar a outra função gerador ou objeto iterável.</dd>
+ <dt>{{jsxref("Global_Objects/Array", "[]")}}</dt>
+ <dd>Array initializer/literal syntax.</dd>
+ <dt>{{jsxref("Operators/Object_initializer", "{}")}}</dt>
+ <dd>Object initializer/literal syntax.</dd>
+ <dt>{{jsxref("Global_Objects/RegExp", "/ab+c/i")}}</dt>
+ <dd>Regular expression literal syntax.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operators/Array_comprehensions", "[for (x of y) x]")}}</dt>
+ <dd>Array comprehensions.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operators/Generator_comprehensions", "(for (x of y) y)")}}</dt>
+ <dd>Generator comprehensions.</dd>
+ <dt>{{jsxref("Operators/Grouping", "( )")}}</dt>
+ <dd>Grouping operator.</dd>
+</dl>
+
+<h3 id="Left-hand-side_expressions">Left-hand-side expressions</h3>
+
+<p>Left values are the destination of an assignment.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/Property_accessors", "Property accessors", "", 1)}}</dt>
+ <dd>Member operators provide access to a property or method of an object<br>
+ (<code>object.property</code> and <code>object["property"]</code>).</dd>
+ <dt>{{jsxref("Operators/new", "new")}}</dt>
+ <dd>The <code>new</code> operator creates an instance of a constructor.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operators/super", "super")}}</dt>
+ <dd>The <code>super</code> keyword calls the parent constructor.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operators/Spread_operator", "...obj")}}</dt>
+ <dd>The spread operator allows an expression to be expanded in places where multiple arguments (for function calls) or multiple elements (for array literals) are expected.</dd>
+</dl>
+
+<h3 id="Incremento_e_decremento">Incremento e decremento</h3>
+
+<p>Operadores sufixo/prefixo para incremento e sufixo/prefixo para decremento.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "A++", "#Increment")}}</dt>
+ <dd>Operador sufixo para incremento.</dd>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "A--", "#Decrement")}}</dt>
+ <dd>Operador sufixo para decremento.</dd>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "++A", "#Increment")}}</dt>
+ <dd>Operador prefixo para incremento.</dd>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "--A", "#Decrement")}}</dt>
+ <dd>Operador prefixo para decremento.</dd>
+</dl>
+
+<h3 id="Unary_operators">Unary operators</h3>
+
+<p>A unary operation is operation with only one operand.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/delete", "delete")}}</dt>
+ <dd>The <code>delete</code> operator deletes a property from an object.</dd>
+ <dt>{{jsxref("Operators/void", "void")}}</dt>
+ <dd>The <code>void</code> operator discards an expression's return value.</dd>
+ <dt>{{jsxref("Operators/typeof", "typeof")}}</dt>
+ <dd>The <code>typeof</code> operator determines the type of a given object.</dd>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "+", "#Unary_plus")}}</dt>
+ <dd>The unary plus operator converts its operand to Number type.</dd>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "-", "#Unary_negation")}}</dt>
+ <dd>The unary negation operator converts its operand to Number type and then negates it.</dd>
+ <dt>{{jsxref("Operators/Bitwise_Operators", "~", "#Bitwise_NOT")}}</dt>
+ <dd>Bitwise NOT operator.</dd>
+ <dt>{{jsxref("Operators/Logical_Operators", "!", "#Logical_NOT")}}</dt>
+ <dd>Logical NOT operator.</dd>
+</dl>
+
+<h3 id="Operadores_aritméticos">Operadores aritméticos</h3>
+
+<p>Arithmetic operators take numerical values (either literals or variables) as their operands and return a single numerical value.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "+", "#Addition")}}</dt>
+ <dd>Operador de soma.</dd>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "-", "#Subtraction")}}</dt>
+ <dd>Operador de subtração.</dd>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "/", "#Division")}}</dt>
+ <dd>Operador de divisão.</dd>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "*", "#Multiplication")}}</dt>
+ <dd>Operador de multiplicação.</dd>
+ <dt>{{jsxref("Operators/Arithmetic_Operators", "%", "#Remainder")}}</dt>
+ <dd>Remainder operator.</dd>
+</dl>
+
+<h3 id="Operadores_relacionais">Operadores relacionais</h3>
+
+<p>A comparison operator compares its operands and returns a <code>Boolean</code> value based on whether the comparison is true.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/in", "in")}}</dt>
+ <dd>The <code>in</code> operator determines whether an object has a given property.</dd>
+ <dt>{{jsxref("Operators/instanceof", "instanceof")}}</dt>
+ <dd>The <code>instanceof</code> operator determines whether an object is an instance of another object.</dd>
+ <dt>{{jsxref("Operators/Comparison_Operators", "&lt;", "#Less_than_operator")}}</dt>
+ <dd>Operador "menor que".</dd>
+ <dt>{{jsxref("Operators/Comparison_Operators", "&gt;", "#Greater_than_operator")}}</dt>
+ <dd>Operador "maior que".</dd>
+ <dt>{{jsxref("Operators/Comparison_Operators", "&lt;=", "#Less_than_or_equal_operator")}}</dt>
+ <dd>Operador "menor ou igual que".</dd>
+ <dt>{{jsxref("Operators/Comparison_Operators", "&gt;=", "#Greater_than_or_equal_operator")}}</dt>
+ <dd>Operador "maior ou igual que".</dd>
+</dl>
+
+<h3 id="Operadores_de_igualdade">Operadores de igualdade</h3>
+
+<p>O resultador de um operador de igualdade é do tipo <code>Booleano</code> baseado que a comparação seja verdadeira.</p>
+
+<p>{{jsxref("Operators/Comparison_Operators", "==", "#Equality")}}</p>
+
+<dl>
+ <dd>Operadores de igualdade.</dd>
+ <dt>{{jsxref("Operators/Comparison_Operators", "!=", "#Inequality")}}</dt>
+ <dd>Inequality operator.</dd>
+ <dt>{{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}</dt>
+ <dd>Identity operator.</dd>
+ <dt>{{jsxref("Operators/Comparison_Operators", "!==", "#Nonidentity")}}</dt>
+ <dd>Nonidentity operator.</dd>
+</dl>
+
+<h3 id="Bitwise_shift_operators">Bitwise shift operators</h3>
+
+<p>Operations to shift all bits of the operand.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/Bitwise_Operators", "&lt;&lt;", "#Left_shift")}}</dt>
+ <dd>Bitwise left shift operator.</dd>
+ <dt>{{jsxref("Operators/Bitwise_Operators", "&gt;&gt;", "#Right_shift")}}</dt>
+ <dd>Bitwise right shift operator.</dd>
+ <dt>{{jsxref("Operators/Bitwise_Operators", "&gt;&gt;&gt;", "#Unsigned_right_shift")}}</dt>
+ <dd>Bitwise unsigned right shift operator.</dd>
+</dl>
+
+<h3 id="Binary_bitwise_operators">Binary bitwise operators</h3>
+
+<p>Bitwise operators treat their operands as a set of 32 bits (zeros and ones) and return standard JavaScript numerical values.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/Bitwise_Operators", "&amp;", "#Bitwise_AND")}}</dt>
+ <dd>Bitwise AND.</dd>
+ <dt>{{jsxref("Operators/Bitwise_Operators", "|", "#Bitwise_OR")}}</dt>
+ <dd>Bitwise OR.</dd>
+ <dt>{{jsxref("Operators/Bitwise_Operators", "^", "#Bitwise_XOR")}}</dt>
+ <dd>Bitwise XOR.</dd>
+</dl>
+
+<h3 id="Operadores_Lógicos_Binários">Operadores Lógicos Binários</h3>
+
+<p>Operadores lógicos são normalmente usados com boolean (logical) valores, e quando eles são, eles retornam um valor Boolean.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/Logical_Operators", "&amp;&amp;", "#Logical_AND")}}</dt>
+ <dd>AND.</dd>
+ <dt>{{jsxref("Operators/Logical_Operators", "||", "#Logical_OR")}}</dt>
+ <dd> OR.</dd>
+</dl>
+
+<h3 id="Operador_de_Condicional_ternário">Operador de Condicional (ternário)</h3>
+
+<dl>
+ <dt>{{jsxref("Operators/Conditional_Operator", "(condition ? ifTrue : ifFalse)")}}</dt>
+ <dd>
+ <p>O operador condicional retorna um dos dois valores baseado no valor lógico da condição.</p>
+ </dd>
+</dl>
+
+<h3 id="Assignment_operators">Assignment operators</h3>
+
+<p>An assignment operator assigns a value to its left operand based on the value of its right operand.</p>
+
+<dl>
+ <dt>{{jsxref("Operators/Assignment_Operators", "=", "#Assignment")}}</dt>
+ <dd>Assignment operator.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "*=", "#Multiplication_assignment")}}</dt>
+ <dd>Multiplication assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "/=", "#Division_assignment")}}</dt>
+ <dd>Division assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "%=", "#Remainder_assignment")}}</dt>
+ <dd>Remainder assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "+=", "#Addition_assignment")}}</dt>
+ <dd>Addition assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "-=", "#Subtraction_assignment")}}</dt>
+ <dd>Subtraction assignment</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "&lt;&lt;=", "#Left_shift_assignment")}}</dt>
+ <dd>Left shift assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "&gt;&gt;=", "#Right_shift_assignment")}}</dt>
+ <dd>Right shift assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "&gt;&gt;&gt;=", "#Unsigned_right_shift_assignment")}}</dt>
+ <dd>Unsigned right shift assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "&amp;=", "#Bitwise_AND_assignment")}}</dt>
+ <dd>Bitwise AND assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "^=", "#Bitwise_XOR_assignment")}}</dt>
+ <dd>Bitwise XOR assignment.</dd>
+ <dt>{{jsxref("Operators/Assignment_Operators", "|=", "#Bitwise_OR_assignment")}}</dt>
+ <dd>Bitwise OR assignment.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Operators/Destructuring_assignment", "[a, b] = [1, 2]")}}<br>
+ {{experimental_inline}} {{jsxref("Operators/Destructuring_assignment", "{a, b} = {a:1, b:2}")}}</dt>
+ <dd>
+ <p>Destructuring assignment allows you to assign the properties of an array or object to variables using syntax that looks similar to array or object literals.</p>
+ </dd>
+</dl>
+
+<h3 id="Comma_operator">Comma operator</h3>
+
+<dl>
+ <dt>{{jsxref("Operators/Comma_Operator", ",")}}</dt>
+ <dd>The comma operator allows multiple expressions to be evaluated in a single statement and returns the result of the last expression.</dd>
+</dl>
+
+<h3 id="Non-standard_features">Non-standard features</h3>
+
+<dl>
+ <dt>{{non-standard_inline}} {{jsxref("Operators/Legacy_generator_function", "Legacy generator function", "", 1)}}</dt>
+ <dd>The <code>function</code> keyword can be used to define a legacy generator function inside an expression. To make the function a legacy generator, the function body should contains at least one {{jsxref("Operators/yield", "yield")}} expression.</dd>
+ <dt>{{non-standard_inline}} {{jsxref("Operators/Expression_closures", "Expression closures", "", 1)}}</dt>
+ <dd>The expression closure syntax is a shorthand for writing simple function.</dd>
+</dl>
+
+<h2 id="Specifications">Specifications</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>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11', 'Expressions')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-ecmascript-language-expressions', 'ECMAScript Language: Expressions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Novo: Spread operator, destructuring assignment, <code>super</code> keyword, Array comprehensions, Generator comprehensions</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">Operator precedence</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/inicializador_objeto/index.html b/files/pt-br/web/javascript/reference/operators/inicializador_objeto/index.html
new file mode 100644
index 0000000000..ac59b4e7f8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/inicializador_objeto/index.html
@@ -0,0 +1,392 @@
+---
+title: Inicializador de Objeto
+slug: Web/JavaScript/Reference/Operators/Inicializador_Objeto
+tags:
+  - ECMAScript 2015
+  - JSON
+  - JavaScript
+  - Literal
+  - Métodos
+  - Objeto
+  - Propriedades
+  - mutação
+translation_of: Web/JavaScript/Reference/Operators/Object_initializer
+---
+<div>{{JsSidebar("Operadores")}}</div>
+
+<p>Objetos podem ser inicializados utilizando <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object"><code>new Object()</code></a>,<code> <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Object/create">Object.create()</a></code>, ou a notação <em>literal</em>. Um inicializador de objetos é uma lista de zero ou mais pares de <em>propriedade: valor</em>, separados por vírgula e fechado por um par de chaves (<code>{}</code>).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush: js">var o = {};
+var o = { a: "foo", b: 42, c: {} };
+
+var a = "foo", b = 42, c = {};
+var o = { a: a, b: b, c: c };
+
+var o = {
+  <var>propriedade: function </var>([<var>parâmetros</var>]) {},
+  get <var>propriedade</var>() {},
+  set <var>propriedade</var>(<var>valor</var>) {},
+};
+</pre>
+
+<h3 id="Novas_notações_em_ECMAScript_2015">Novas notações em ECMAScript 2015</h3>
+
+<p>Por favor, verifique o suporte das anotações na tabela de compatibilidade. Em ambientes que não dão suporte às anotações, ocorrerá erros de sintaxe.</p>
+
+<pre class="brush: js">// // Abreviação em nomes de propriedades (ES2015)
+var a = "foo", b = 42, c = {};
+var o = { a, b, c };
+
+// // Abreviação em nomes de métodos (ES2015)
+var o = {
+  <var>property</var>([<var>parameters</var>]) {},
+  get <var>property</var>() {},
+  set <var>property</var>(<var>value</var>) {},
+};
+
+// Nomes de propriedades computados (ES2015)
+var prop = "foo";
+var o = {
+  [prop]: "hey",
+  ["b" + "ar"]: "there",
+};</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Um inicializador de objetos é uma expressão que descreve a inicialização de um {{jsxref("Object")}}. Objects consiste de <em>propriedades</em>, as quais descrevem um objeto. Os valores das propriedades de um objeto podem ser tipos de dados {{Glossary("primitivos")}} ou outros objetos .</p>
+
+<h3 id="Criando_objetos">Criando objetos</h3>
+
+<p>Um objeto vazio, sem propriedades, pode ser criado como: </p>
+
+<pre class="brush: js">var object = {};</pre>
+
+<p>Contudo, a vantagem em utilizar a notação <em>literal </em>ou o <em>inicializador</em> é a possibilidade de rapidamente criar objetos com propriedades dentro de chaves (<code>{}</code>). Você simplesmente cria uma lista de pares <em>chave: valor</em>, separados por vírgula. O código abaixo cria um objeto com três propriedades, sendo as chaves "foo", "age" e "baz", com seus respectivos valores, tipo string de valor "bar", tipo number de valor 42 e, por último, um outro objeto com seus respectivos pares de <em>chave: valor</em>. </p>
+
+<pre class="brush: js">var object = {
+  foo: "bar",
+  age: 42,
+  baz: { myProp: 12 },
+}</pre>
+
+<h3 id="Acessando_propriedades">Acessando propriedades</h3>
+
+<p>Uma vez que você criou um objeto, é interessante que possa ler ou alterá-lo. As propriedades de um objeto podem ser acessadas utilizando a notação de ponto ou colchetes. Veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Property_Accessors">assessores de propriedade</a> para mais informações.</p>
+
+<pre class="brush: js">object.foo; // "bar"
+object["age"]; // 42
+
+object.foo = "baz";
+</pre>
+
+<h3 id="Definições_de_propriedade">Definições de propriedade</h3>
+
+<p>Nós temos aprendido como descrever propriedades utilizando a sintaxe <em>inicializador</em>. No entanto, às vezes, há variáveis que queremos inserir em nosso objeto. Então teremos um código parecido como abaixo: </p>
+
+<pre class="brush: js">var a = "foo",
+    b = 42,
+    c = {};
+
+var o = {
+  a: a,
+  b: b,
+  c: c
+};</pre>
+
+<p>Com ECMAScript 2015, há uma notação mais curta que possibilita atingir o mesmo resultado: </p>
+
+<pre class="brush: js">var a = "foo",
+    b = 42,
+    c = {};
+
+// Abreviação em nomes de propriedades (ES2015)
+var o = { a, b, c };
+
+// Em outras palavras,
+console.log((o.a === { a }.a)); // true
+</pre>
+
+<h4 id="Duplicação_em_nomes_de_propriedades">Duplicação em nomes de propriedades</h4>
+
+<p>Quando se está utilizando o mesmo nome para suas propriedades, a última sobrescreverá as anteriores.</p>
+
+<pre class="brush: js">var a = {x: 1, x: 2};
+console.log(a); // { x: 2}
+</pre>
+
+<p>Em códigos ECMAScript 5 no modo estrito, duplicação em nomes de propriedades serão consideradas {{jsxref("SyntaxError")}}. Porém, com a introdução de "nomes de propriedades computadas", tornou-se possível a duplicação das propriedades em tempo de execução. Assim, ECMAScript 2015 removeu a restrição.</p>
+
+<pre class="brush: js">function haveES2015DuplicatePropertySemantics(){
+  "use strict";
+  try {
+    ({ prop: 1, prop: 2 });
+
+    // No error thrown, duplicate property names allowed in strict mode
+    return true;
+  } catch (e) {
+    // Error thrown, duplicates prohibited in strict mode
+    return false;
+  }
+}</pre>
+
+<h3 id="Definição_de_métodos">Definição de métodos</h3>
+
+<p>Uma propriedade de um objeto pode se referir à <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/Function">function</a>, ou aos métodos <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/get">getter</a> ou <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/set">setter</a>.</p>
+
+<pre class="brush: js">var o = {
+  <var>propriedade: function </var>([<var>parâmetros</var>]) {},
+  get <var>propriedade</var>() {},
+  set <var>propriedade</var>(<var>valor</var>) {},
+};</pre>
+
+<p>No ECMAScript 2015, uma notação abreviada está disponível, dispensando o uso da palavra reservada "function".</p>
+
+<pre class="brush: js">// Abreviações em nomes de métodos (ES2015)
+var o = {
+  <var>propriedade</var>([<var>parâmetros</var>]) {},
+  get <var>propriedade</var>() {},
+  set <var>propriedade</var>(<var>valor</var>) {},
+  * <var>gerador</var>() {}
+};</pre>
+
+<p>Com ECMAScript 2015, há uma forma concisa em criar propriedades cujo valor é uma função gerador. </p>
+
+<pre class="brush: js">var o = {
+  * <var>gerador</var>() {
+    ...........
+  }
+};</pre>
+
+<p>Mas em ECMAScript 5, você escreveria (lembrar que em ES5 não há geradores):</p>
+
+<pre class="brush: js">var o = {
+  generator<var>: function *</var>() {
+    ...........
+  }
+};</pre>
+
+<p>Para mais informações e exemplos, veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/Definicoes_metodos">definições de método</a>.</p>
+
+<h3 id="Nomes_de_propriedades_computados">Nomes de propriedades computados</h3>
+
+<p>Começando com ECMAScript 2015, a sintaxe <em>inicializador</em> de objeto também suporta "nomes de propriedades computados". Isso permite que você possa inserir uma expressão dentro de colchetes <code>[]</code>, que será computada como o nome de uma propriedade. Isto é semelhante à notação de chaves utilizado em <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Property_Accessors">acessor de propriedade</a>, utilizado para ler a alterar as propriedades existentes em um objeto. Segue um exemplo utilizando a mesma sintaxe em objetos literais: </p>
+
+<pre class="brush: js">// Nomes de propriedades computados (ES2015)
+var i = 0;
+var a = {
+  ["foo" + ++i]: i,
+  ["foo" + ++i]: i,
+  ["foo" + ++i]: i
+};
+
+console.log(a.foo1); // 1
+console.log(a.foo2); // 2
+console.log(a.foo3); // 3
+
+var param = 'size';
+var config = {
+  [param]: 12,
+  ["mobile" + param.charAt(0).toUpperCase() + param.slice(1)]: 4
+};
+
+console.log(config); // { size: 12, mobileSize: 4 }</pre>
+
+<h3 id="Mutação_Prototype">Mutação Prototype </h3>
+
+<p>Uma definição de propriedade na forma de  <code>__proto__: valor</code> or <code>"__proto__": valor</code> não cria uma propriedade com o nome  <code>__proto__</code>.  Inclusive, se o valor fornecido for um objeto ou <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/null"><code>null</code></a>, muda o <code>[[Prototype]]</code> do objeto criado para o valor informado. (Se o valor fornecido não é um objeto ou null, o valor não será alterado.)</p>
+
+<pre class="brush: js">var obj1 = {};
+assert(Object.getPrototypeOf(obj1) === Object.prototype);
+
+var obj2 = { __proto__: null };
+assert(Object.getPrototypeOf(obj2) === null);
+
+var protoObj = {};
+var obj3 = { "__proto__": protoObj };
+assert(Object.getPrototypeOf(obj3) === protoObj);
+
+var obj4 = { __proto__: "not an object or null" };
+assert(Object.getPrototypeOf(obj4) === Object.prototype);
+assert(!obj4.hasOwnProperty("__proto__"));
+</pre>
+
+<p>Apenas uma única mudança em prototype é permitida em um objeto: múltiplas mudanças gera erro de sintaxe. </p>
+
+<p>Definições de propriedade que não utilizam da notação de ":", não são consideradas mudanças de prototype: são definições de propriedades que se comportam de forma semelhante às definições utilizando qualquer outro nome. </p>
+
+<pre class="brush: js">var __proto__ = "variable";
+
+var obj1 = { __proto__ };
+assert(Object.getPrototypeOf(obj1) === Object.prototype);
+assert(obj1.hasOwnProperty("__proto__"));
+assert(obj1.__proto__ === "variable");
+
+var obj2 = { __proto__() { return "hello"; } };
+assert(obj2.__proto__() === "hello");
+
+var obj3 = { ["__prot" + "o__"]: 17 };
+assert(obj3.__proto__ === 17);
+</pre>
+
+<h2 id="Notação_de_objeto_literal_vs_JSON">Notação de objeto literal vs JSON</h2>
+
+<p>A notação de objeto literal não é a mesma de <strong>J</strong>ava<strong>S</strong>cript <strong>O</strong>bject <strong>N</strong>otation (<a href="/pt-BR/docs/JSON">JSON</a>).  Mesmo que possuam semelhanças, há as seguintes diferenças:</p>
+
+<ul>
+ <li>JSON permite definições de propriedades utilizando apenas aspas duplas, como  <code>"propriedade": valor</code>.  E a definição não pode ser abreviada.</li>
+ <li>Os valores JSON podem ser apenas strings, numbers, arrays, <code>true</code>, <code>false</code>, <code>null</code>, ou outro objeto JSON.</li>
+ <li>Uma função como valor (veja "Métodos" acima) não pode ser atribuido em JSON.</li>
+ <li>Objetos como {{jsxref("Date")}} serão do tipo string após {{jsxref("JSON.parse()")}}.</li>
+ <li>{{jsxref("JSON.parse()")}} rejeitará "nomes de propriedades computados" e um erro será lançado.</li>
+</ul>
+
+<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>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.1.5', 'Object Initializer')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/get">getter</a> e <a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/set">setter</a> adicionados.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-object-initializer', 'Object Initializer')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Abreviações de nomes em propriedades/métodos e nomes de propriedados computados foram adicionados.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-object-initializer', 'Object Initializer')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<div>{{CompatibilityTable}}</div>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatChrome(1.0)}}</td>
+   <td>{{CompatGeckoDesktop("1.0")}}</td>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+  </tr>
+  <tr>
+   <td>Nomes de propriedades computados</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>Abreviação em nomes de propriedades</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("33")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Abreviação em nomes de métodos</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatGeckoDesktop("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("1.0")}}</td>
+   <td>1</td>
+   <td>1</td>
+   <td>1</td>
+   <td>{{CompatChrome(1.0)}}</td>
+  </tr>
+  <tr>
+   <td>Nomes de propriedades computados</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Abreviação em nomes de propriedades</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("33")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+  <tr>
+   <td>Abreviação em nomes de métodos</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatGeckoMobile("34")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome(42.0)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Property_Accessors">Assesores de propriedade</a></li>
+ <li><code><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/get">get</a></code> / <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/set">set</a></code></li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/Definicoes_metodos">Definições de métodos</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar">Lexical grammar</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/instanceof/index.html b/files/pt-br/web/javascript/reference/operators/instanceof/index.html
new file mode 100644
index 0000000000..0627860a38
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/instanceof/index.html
@@ -0,0 +1,194 @@
+---
+title: instanceof
+slug: Web/JavaScript/Reference/Operators/instanceof
+translation_of: Web/JavaScript/Reference/Operators/instanceof
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<div>O operador <strong><code>instanceof</code></strong> testa se um objeto tem, em seu prototype, a função construtora.</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><em>objeto</em> instanceof <em>construtor</em></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<dl>
+ <dt><code>objeto</code></dt>
+ <dd>O objeto a ser testado</dd>
+</dl>
+
+<dl>
+ <dt><code>construtor</code></dt>
+ <dd>Função construtora a ser verificada</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O operador <span style="font-family: Consolas, Monaco, 'Andale Mono', monospace;">instanceof</span> testa a presença da função construtora no prototype do objeto.</p>
+
+<pre class="brush: js">// defenindo construtores
+function C(){}
+function D(){}
+
+var o = new C();
+
+// true, porque: Object.getPrototypeOf(o) === C.prototype
+o instanceof C;
+
+// false, porque D.prototype não está no prototype desse objeto
+o instanceof D;
+
+o instanceof Object; // true, porque:
+C.prototype instanceof Object // true
+
+C.prototype = {};
+var o2 = new C();
+
+o2 instanceof C; // true
+
+// false, porque C.prototype não está mais no prototype desse objeto
+o instanceof C;
+
+D.prototype = new C(); // use inheritance
+var o3 = new D();
+o3 instanceof D; // true
+o3 instanceof C; // true
+</pre>
+
+<p>Note que o resultado do <span style="font-family: Consolas, Monaco, 'Andale Mono', monospace;">instanceof</span> pode alterar quando a gente altera o prototype da função construtora. No entanto, a gente não pode alterar (por padrão) o prototype do objeto. Só é possível fazer essa alteração usando a pseudopropriedade <span style="font-family: Consolas, Monaco, 'Andale Mono', monospace;">__proto__.</span></p>
+
+<h3 id="instanceof_and_multiple_context_(e.g._frames_or_windows)"><code>instanceof</code> and multiple context (e.g. frames or windows)</h3>
+
+<p>Different scope have different execution environments. This means that they have different built-ins (different global object, different constructors, etc.). This may result in unexpected results. For instance, <code>[] instanceof window.frames[0].Array</code> will return <code>false</code>, because <code>Array.prototype !== </code><code>window.frames[0].Array</code> and arrays inherit from the former. This may not make sense at first but when you start dealing with multiple frames or windows in your script and pass objects from one context to another via functions, this will be a valid and strong issue. For instance, you can securely check if a given object is in fact an Array using <code>Array.isArray(myObj)</code></p>
+
+<div class="note"><strong>Note for Mozilla developers:</strong><br>
+In code using XPCOM <code>instanceof</code> has special effect: <code>obj instanceof </code><em><code>xpcomInterface</code></em> (e.g. <code>Components.interfaces.nsIFile</code>) calls <code>obj.QueryInterface(<em>xpcomInterface</em>)</code> and returns <code>true</code> if QueryInterface succeeded. A side effect of such call is that you can use <em><code>xpcomInterface</code></em>'s properties on <code>obj</code> after a successful <code>instanceof</code> test. Unlike standard JavaScript globals, the test <code>obj instanceof xpcomInterface </code>works as expected even if <code>obj</code> is from a different scope.</div>
+
+<h2 id="Examples">Examples</h2>
+
+<h3 id="Demonstrating_that_String_and_Date_are_of_type_Object_and_exceptional_cases">Demonstrating that <code>String</code> and <code>Date</code> are of type <code>Object</code> and exceptional cases</h3>
+
+<p>The following code uses <code>instanceof</code> to demonstrate that <code>String</code> and <code>Date</code> objects are also of type <code>Object</code> (they are derived from <code>Object</code>).</p>
+
+<p>However, objects created with the object literal notation are an exception here: Although the prototype is undefined, <code>instanceof Object</code> returns <code>true</code>.</p>
+
+<pre class="brush: js">var simpleStr = "This is a simple string";
+var myString  = new String();
+var newStr    = new String("String created with constructor");
+var myDate    = new Date();
+var myObj     = {};
+
+simpleStr instanceof String; // returns false, checks the prototype chain, finds undefined
+myString  instanceof String; // returns true
+newStr    instanceof String; // returns true
+myString  instanceof Object; // returns true
+
+myObj instanceof Object;    // returns true, despite an undefined prototype
+({})  instanceof Object;    // returns true, same case as above
+
+myString instanceof Date;   // returns false
+
+myDate instanceof Date;     // returns true
+myDate instanceof Object;   // returns true
+myDate instanceof String;   // returns false
+</pre>
+
+<h3 id="Demonstrating_that_mycar_is_of_type_Car_and_type_Object">Demonstrating that <code>mycar</code> is of type <code>Car</code> and type <code>Object</code></h3>
+
+<p>The following code creates an object type <code>Car</code> and an instance of that object type, <code>mycar</code>. The <code>instanceof</code> operator demonstrates that the <code>mycar</code> object is of type <code>Car</code> and of type <code>Object</code>.</p>
+
+<pre class="brush: js">function Car(make, model, year) {
+  this.make = make;
+  this.model = model;
+  this.year = year;
+}
+var mycar = new Car("Honda", "Accord", 1998);
+var a = mycar instanceof Car;    // retorna true
+var b = mycar instanceof Object; // retorna true
+</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>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial. Implementada no JavaScript 1.4</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.8.6', 'The instanceof operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-relational-operators', 'Relational Operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof" title="/en-US/docs/JavaScript/Reference/Operators/typeof">typeof</a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/new.target/index.html b/files/pt-br/web/javascript/reference/operators/new.target/index.html
new file mode 100644
index 0000000000..e932b452ed
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/new.target/index.html
@@ -0,0 +1,98 @@
+---
+title: new.target
+slug: Web/JavaScript/Reference/Operators/new.target
+tags:
+  - Classes
+  - ECMAScript6
+  - JavaScript
+  - Referencia
+translation_of: Web/JavaScript/Reference/Operators/new.target
+---
+<div>{{JSSidebar("Operators")}}</div>
+
+<p>A propriedade <code>new.target</code> permite que você detecte quando uma função ou construtor foi chamado utilizando o operador new. Em construtores e funções instaciadas com o  operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a> , <code>new.target</code> retorna a referência ao  construtor ou função. Em chamadas normais de funções , <code>new.target</code> é {{jsxref("undefined")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">new.target</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A sintaxe <code>new.target</code> consiste na palavra- chave <code>"new</code>", o ponto, e o nome da propriedade <code>"target"</code>. Normalmente "<code>new."</code> serve como um contexto para a propriedade de acesso, mas aqui  <code>"new."</code> não é exatamente um objeto. Em chamadas de construtores, entretanto, <code>new.target</code> se refere ao construtor invocado pelo <code>new</code> e então "<code>new.</code>" se torna um contexto virtual.</p>
+
+<p><code>new.target</code>  é uma propriedade meta que é disponibilizada para todas as funções. Em funções do tipo flecha <code>=&gt;</code>, <code>new.target</code> se refere ao <code>new.target</code> em torno da função.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="new.target_em_chamadas_de_Função">new.target em chamadas de Função</h3>
+
+<p>Em chamadas normais de função  (diferente de chamadas a funções do tipo construtor), <code>new.target</code> é {{jsxref("undefined")}}. Isso permite que você detecte se a função foi chamada como um novo construtor.</p>
+
+<pre class="brush: js">function Foo() {
+  if (!new.target) throw 'Foo() must be called with new';
+  console.log('Foo instanciado com new');
+}
+
+Foo(); // throws "Foo() must be called with new"
+new Foo(); // logs "Foo instanciado com new"
+</pre>
+
+<h3 id="new.target_em_Construtores">new.target em Construtores</h3>
+
+<p>Em classes construtoras, <code>new.target</code> se refere ao construtor que foi diretamente invocado pelo <code>new</code>. Isto também é o caso se o construtor é uma classe pai e foi delegado pelo construtor de um filho.</p>
+
+<pre class="brush: js">class A {
+  constructor() {
+    console.log(new.target.name);
+  }
+}
+
+class B extends A { constructor() { super(); } }
+
+var a = new A(); // logs "A"
+var b = new B(); // logs "B"
+
+class C { constructor() { console.log(new.target); } }
+class D extends C { constructor() { super(); } }
+
+var c = new C(); // logs class C{constructor(){console.log(new.target);}}
+var d = new D(); // logs class D extends C{constructor(){super();}}</pre>
+
+<p class="summary">A partir do exemplo acima das classes C e D, mostra que new.target aponta para a definição da classe na qual foi inicializada. Exemplo, quando D foi inicializado utilizando new, a definição da classe D foi impressa e similiarmente ao caso de C, a classe C foi impressa.</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>{{SpecName('ES2015', '#sec-built-in-function-objects', 'Built-in Function Objects')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-built-in-function-objects', 'Built-in Function Objects')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browser">Compatibilidade com browser</h2>
+
+<div class="hidden">A tabela de compatibilidade nesta página é gerada de dados estruturados. se você deseja contribuir para os dados, por favor acesse <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie uma requisição de atualização.</div>
+
+<p>{{Compat("javascript.operators.new_target")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions">funções</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/new/index.html b/files/pt-br/web/javascript/reference/operators/new/index.html
new file mode 100644
index 0000000000..37d4a0d273
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/new/index.html
@@ -0,0 +1,224 @@
+---
+title: new operator
+slug: Web/JavaScript/Reference/Operators/new
+tags:
+  - Expressões Left-hand-side
+  - JavaScript
+  - Operador
+translation_of: Web/JavaScript/Reference/Operators/new
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>O <strong>operador <code>new</code></strong><code> </code>cria uma instancia de um tipo de objeto definido pelo usuário ou de um dos tipos nativos (<em>built-in</em>) que possuem uma função construtora.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/expressions-newoperator.html")}} A fonte deste exemplo interativo é armazenada em um repositório do GitHub. Se você gostaria de contribuir para o projeto de exemplos interativos, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie uma requisição de comando pull.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">new <em>construtor</em>[([<em>argumentos</em>])]</pre>
+
+<h3 id="Parametros">Parametros</h3>
+
+<dl>
+ <dt><code>construtor</code></dt>
+ <dd>Uma função que especifica o tipo da instancia do objetivo.</dd>
+</dl>
+
+<dl>
+ <dt><code>argumentos</code></dt>
+ <dd>Uma lista de valores com os quais o construtor será chamado.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Criar um objeto definido pelo usuário requer dois passos:</p>
+
+<ol>
+ <li>Definir o tipo de objeto através da escrita de uma função.</li>
+ <li>Criar uma instancia do objeto utilizando <code>new</code>.</li>
+</ol>
+
+<p>Para definir um tipo de objeto, crie uma função para o tipo de objetivo que especifica seu nome e propriedades. Um objeto pode ter uma propriedade que é um outro objeto. Veja os exemplos abaixo:</p>
+
+<p>Quando o código <code>new <em>Foo</em>(...)</code> é executado, acontece o seguinte::</p>
+
+<ol>
+ <li>Um novo objeto é criado, herdando de <code><em>Foo</em>.prototype</code>.</li>
+ <li>A função construtora <em>F<code>oo</code></em> é chamado com os argumentos especificados, e com <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">this</a></code> vinculado ao novo objeto criado. <code>new F<em>oo</em></code> é equivalente a <code>new </code><em>F<code>oo</code></em><code>()</code>, ou seja, se nenhuma lista de argumentos for especificada, <em>F<code>oo</code></em> é chamado sem argumentos.</li>
+ <li>O objeto retornado pela função construtora é o resultado de toda expressão <code>new</code>. Se a função construtora não retornar um objeto explicitamente, o objeto criado no passo 1 é então usado. (Normalmente construtores não retornam um valor, mas eles podem escolher fazê-lo se eles quiserem sobrescrever o processo normal de criação de objeto.)</li>
+</ol>
+
+<p>Você sempre pode adicionar uma propriedade à um objeto definido previamente. Por exemplo, <code>carro1.cor = "preta"</code> adiciona a propriedade <code>cor</code> em <code>carro1</code>, e atribui a ela o valor de "<code>preta</code>".  Entretanto, isso não afeta os outros objetos. Para adicionar a nova propriedade a todos objetos do mesmo tipo, você deve adicionar a propriedade à definição do tipo de objeto <code>Carro</code>.</p>
+
+<p>Você pode adicionar uma propriedade compartilhada à um tipo de objeto definido anteriormente através do uso da propriedade <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype">Function.prototype</a></code>. Isso define uma propriedade que é compartilhada por todos os objetos criados com essa função, ao invés de apenas uma instancia do tipo de objeto. O código a seguir adiciona uma propriedade cor com valor <code>null</code> à todos objetos do tipo <code>carro</code>, e então sobrescreve aquele valor com a string "<code>preta</code>" somente no objeto de instancia <code>carro1</code>. Para mais informações veja <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/prototype">prototype</a>.</p>
+
+<pre class="brush: js">function Carro() {}
+carro1 = new Carro();
+
+console.log(carro1.cor);    // undefined
+
+Carro.prototype.cor = null;
+console.log(carro1.cor);    // null
+
+carro1.cor = "preta";
+console.log(carro1.cor);   // preta
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Tipo_de_objeto_e_instância_de_objeto">Tipo de objeto e instância de objeto</h3>
+
+<p>Suponha que você quer criar um tipo de objeto para carros. Você quer que esse tipo de objeto se chame <code>carro</code>, e quer que ele tenha propriedade para fabricante, modelo e ano. Para fazer isso, você escreveria a função a seguir:</p>
+
+<pre class="brush: js">function Carro(fabricante, modelo, ano) {
+  this.fabricante = fabricante;
+  this.modelo = modelo;
+  this.ano = ano;
+}
+</pre>
+
+<p>Agora você pode criar um objeto chamado <code>meucarro</code> como a seguir:</p>
+
+<pre class="brush: js">var meucarro = new Carro("Eagle", "Talon TSi", 1993);
+</pre>
+
+<p>Essa declaração cria <code>meucarro</code> e atribui a ele os valores especificados as suas propriedades. Então o valor de  <code>meucarro.fabricante</code> é a string "Eagle", <code>meucarro.ano</code> é o inteiro 1993, e assim sucessivamente.</p>
+
+<p>Você pode criar qualquer numero de objetos <code>carro</code> através de chamadas a <code>new</code>. Por exemplo:</p>
+
+<pre class="brush: js">var carrodoken = new Carro("Nissan", "300ZX", 1992);
+</pre>
+
+<h3 id="Propriedade_do_objeto_que_é_outro_objeto">Propriedade do objeto que é outro objeto</h3>
+
+<p>Suponha que você defina um objeto chamado <code>pessoa</code> como a seguir:</p>
+
+<pre class="brush: js">function Pessoa(nome, idade, sexo) {
+  this.nome = nome;
+  this.idade = idade;
+  this.sexo = sexo;
+}
+</pre>
+
+<p>E então instancia dois novos objetos <code>pessoa</code> como a seguir:</p>
+
+<pre class="brush: js">var rand = new Pessoa("Rand McNally", 33, "M");
+var ken = new Pessoa("Ken Jones", 39, "M");
+</pre>
+
+<p>Então você pode reescrever a definição de <code>carro</code> para incluir uma propriedade dono que aceita um objeto pessoa, como a seguir:</p>
+
+<pre class="brush: js">function Carro(fabricante, modelo, ano, dono) {
+  this.fabricante = fabricante;
+  this.modelo = modelo;
+  this.ano = ano;
+  this.dono = dono;
+}
+</pre>
+
+<p>Para instanciar os novos objetos, você então usa o seguinte:</p>
+
+<pre class="brush: js">var carro1 = new Carro("Eagle", "Talon TSi", 1993, rand);
+var carro2 = new Carro("Nissan", "300ZX", 1992, ken);
+</pre>
+
+<p>Ao invés de passar uma string ou valor inteiro quando criar os novos objetos, as definições acima passam objetos <code>rand</code> e <code>ken</code> como os parâmetros para os donos. Para descobrir o nome do dono do <code>carro2</code>, você pode acessar a seguinte propriedade:</p>
+
+<pre class="brush: js">carro2.dono.nome
+</pre>
+
+<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>{{SpecName('ESDraft', '#sec-new-operator', 'The new Operator')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-new-operator', 'The new Operator')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.2.2', 'The new Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-11.2.2', 'The new Operator')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-11.2.2', 'The new Operator')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Implementado no JavaScript 1.0.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browser">Compatibilidade de browser </h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("Reflect.construct()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/operador_condicional/index.html b/files/pt-br/web/javascript/reference/operators/operador_condicional/index.html
new file mode 100644
index 0000000000..9b36afca80
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/operador_condicional/index.html
@@ -0,0 +1,171 @@
+---
+title: Operador Condicional Ternário
+slug: Web/JavaScript/Reference/Operators/Operador_Condicional
+tags:
+  - JavaScript
+  - Operadores Condicionais
+translation_of: Web/JavaScript/Reference/Operators/Conditional_Operator
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<h2 id="Summary" name="Summary">Sumário</h2>
+
+<p>O <strong>operador condicional (ternário)</strong> é o único operador JavaScript que possui três operandos. Este operador é frequentemente usado como um atalho para a instrução <a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else"><code>if</code></a>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><em>condition</em> ? <em>expr1</em> : <em>expr2</em> </pre>
+
+<h2 id="Parâmetros">Parâmetros</h2>
+
+<dl>
+ <dt><code>condition</code></dt>
+ <dd>Uma expressão que é avaliada como <code>true</code> ou <code>false</code>.</dd>
+</dl>
+
+<dl>
+ <dt><code>expr1</code>, <code>expr2</code></dt>
+ <dd>Expressões com valores de qualquer tipo.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Se <code>condition</code> é <code>true</code>, o operador retornará o valor de <code>expr1</code>; se não, ele retorna o valor de <code>exp2</code>. Por exemplo, para exibir uma mensagem diferente baseada no valor da variável <code>isMember</code>, você poderá utilizar o código (statement) seguinte:</p>
+
+<pre class="brush: js">"The fee is " + (isMember ? "$2.00" : "$10.00")
+</pre>
+
+<p>Conforme o resultado da operação, você também poderá atribuir a variáveis:</p>
+
+<pre class="brush: js">var elvisLives = Math.PI &gt; 4 ? "Yep" : "Nope";</pre>
+
+<p>Também são possíveis múltiplas avaliaçãoes ternárias (nota: o operador condicional é associativo a direita):</p>
+
+<pre class="brush: js"><code class="language-js"><span class="keyword token">var</span> firstCheck <span class="operator token">=</span> <span class="keyword token">false</span><span class="punctuation token">,</span>
+    secondCheck <span class="operator token">=</span> <span class="keyword token">false</span><span class="punctuation token">,</span>
+    access <span class="operator token">=</span> firstCheck <span class="operator token">?</span> <span class="string token">"Access denied"</span> <span class="punctuation token">:</span> secondCheck <span class="operator token">?</span> <span class="string token">"Access denied"</span> <span class="punctuation token">:</span> <span class="string token">"Access granted"</span><span class="punctuation token">;</span>
+
+console<span class="punctuation token">.</span><span class="function token">log<span class="punctuation token">(</span></span> access <span class="punctuation token">)</span><span class="punctuation token">;</span><span class="comment token"> // logs "Access granted"</span></code></pre>
+
+<p>Você também pode usar avaliações ternárias no espaço livre de modo a fazer diferentes operações:</p>
+
+<pre class="brush: js"><code class="language-js"><span class="keyword token">var</span> stop <span class="operator token">=</span> <span class="keyword token">false</span><span class="punctuation token">,</span> age <span class="operator token">=</span> <span class="number token">16</span><span class="punctuation token">;</span>
+
+age <span class="operator token">&gt;</span> <span class="number token">18</span> <span class="operator token">?</span> location<span class="punctuation token">.</span><span class="function token">assign<span class="punctuation token">(</span></span><span class="string token">"continue.html"</span><span class="punctuation token">)</span> <span class="punctuation token">:</span> stop <span class="operator token">=</span> <span class="keyword token">true</span><span class="punctuation token">;</span></code>
+</pre>
+
+<p><span id="result_box" lang="pt"><span class="hps">Você também pode fazer</span> <span class="hps">mais do que uma única operação</span><span class="hps"> em cada</span> <span class="hps">caso,</span> <span class="hps">separando-os por</span> <span class="hps">vírgula</span><span>:</span></span></p>
+
+<pre class="brush: js"><code class="language-js"><span class="keyword token">var</span> stop <span class="operator token">=</span> <span class="keyword token">false</span><span class="punctuation token">,</span> age <span class="operator token">=</span> <span class="number token">23</span><span class="punctuation token">;</span>
+
+age <span class="operator token">&gt;</span> <span class="number token">18</span> <span class="operator token">?</span> <span class="punctuation token">(</span>
+    <span class="function token">alert<span class="punctuation token">(</span></span><span class="string token">"OK, you can go."</span><span class="punctuation token">)</span><span class="punctuation token">,</span>
+    location<span class="punctuation token">.</span><span class="function token">assign<span class="punctuation token">(</span></span><span class="string token">"continue.html"</span><span class="punctuation token">)</span>
+<span class="punctuation token">)</span> <span class="punctuation token">:</span> <span class="punctuation token">(</span>
+    stop <span class="operator token">=</span> <span class="keyword token">true</span><span class="punctuation token">,</span>
+    <span class="function token">alert<span class="punctuation token">(</span></span><span class="string token">"Sorry, you are much too young!"</span><span class="punctuation token">)</span>
+<span class="punctuation token">)</span><span class="punctuation token">;</span></code>
+</pre>
+
+<p><span id="result_box" lang="pt"><span class="hps">Você também pode fazer</span> <span class="hps">mais de uma operação</span> <span class="hps">durante a</span> <span class="hps">atribuição de</span> <span class="hps">um valor</span></span>. Neste caso, <strong><em><span id="result_box" lang="pt"><span class="hps">o último valor</span> <span class="hps">separado por vírgula</span> dentro <strong><em><span id="result_box" lang="pt"><span class="hps">dos</span> <span class="hps">parênteses </span></span></em></strong><span class="hps">será o</span> <span class="hps">valor a ser atribuído</span></span></em></strong>.</p>
+
+<pre class="brush: js"><code class="language-js"><span class="keyword token">var</span> age <span class="operator token">=</span> <span class="number token">16</span><span class="punctuation token">;</span>
+
+<span class="keyword token">var</span> url <span class="operator token">=</span> age <span class="operator token">&gt;</span> <span class="number token">18</span> <span class="operator token">?</span> <span class="punctuation token">(</span>
+    <span class="function token">alert<span class="punctuation token">(</span></span><span class="string token">"OK, you can go."</span><span class="punctuation token">)</span><span class="punctuation token">,</span>
+   <span class="comment token"> // alert returns "undefined", but it will be ignored because
+</span>   <span class="comment token"> // isn't the last comma-separated value of the parenthesis
+</span>    <span class="string token">"continue.html"</span><span class="comment token"> // the value to be assigned if age &gt; 18
+</span><span class="punctuation token">)</span> <span class="punctuation token">:</span> <span class="punctuation token">(</span>
+    <span class="function token">alert<span class="punctuation token">(</span></span><span class="string token">"You are much too young!"</span><span class="punctuation token">)</span><span class="punctuation token">,</span>
+    <span class="function token">alert<span class="punctuation token">(</span></span><span class="string token">"Sorry :-("</span><span class="punctuation token">)</span><span class="punctuation token">,</span>
+   <span class="comment token"> // etc. etc.
+</span>    <span class="string token">"stop.html"</span><span class="comment token"> // the value to be assigned if !(age &gt; 18)
+</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+
+location<span class="punctuation token">.</span><span class="function token">assign<span class="punctuation token">(</span></span>url<span class="punctuation token">)</span><span class="punctuation token">;</span><span class="comment token"> // "stop.html"</span></code></pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentários</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Definição inicial. Implementado em JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.12', 'The conditional operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-conditional-operator', 'Conditional Operator')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores_(browser)">Compatibilidade dos navegadores (browser)</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else">Operador condicional if</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/operador_de_coalescencia_nula/index.html b/files/pt-br/web/javascript/reference/operators/operador_de_coalescencia_nula/index.html
new file mode 100644
index 0000000000..609bfa29fd
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/operador_de_coalescencia_nula/index.html
@@ -0,0 +1,159 @@
+---
+title: Operador de coalescência nula
+slug: Web/JavaScript/Reference/Operators/operador_de_coalescencia_nula
+tags:
+  - JavaScript
+  - Operador
+  - Operadores lógicos
+  - Referencia
+  - coalescencia nula
+  - duas interrogações
+  - nulidade
+translation_of: Web/JavaScript/Reference/Operators/Nullish_coalescing_operator
+---
+<p>{{JSSidebar("Operators")}}</p>
+
+<p>O <strong>operador de coalescência nula (<code>??</code>)</strong> é um operador lógico que retorna o seu operando do lado direito quando o seu operador do lado esquerdo é {{jsxref("null")}} ou {{jsxref("undefined")}}. Caso contrário, ele retorna o seu operando do lado esquerdo.</p>
+
+<p>Ao contrário do <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Operadores_Logicos#OR_Lógico_()">operador lógico OR (<code>||</code>)</a>, o operando esquerdo é retornado se houver um valor <em><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Operadores_Logicos#Short-Circuit_Evaluation">falsy</a></em> (falso) que não seja <code>null</code> ou <code>undefined</code>. Em outras palavras, se você usar <code>||</code> para obter algum valor padrão para outra variável <code>foo</code>, você pode enfrentar comportamentos inesperados se você considerar algum valor falseável como utilizável (eg. <code>''</code> ou <code>0</code>). Veja abaixo alguns exemplos:</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-nullishcoalescingoperator.html")}}</div>
+
+<p class="hidden">O código fonte para este exemplo interativo está armazenado em um repositório do GitHub. Se você gostaria de contribuir para o projeto de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.<br>
+ Veja o <a href="https://github.com/mdn/interactive-examples/pull/1482#issuecomment-553841750">PR #1482</a> sobre a adição deste exemplo.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><var>exprEsq</var> ?? <var>exprDir</var>
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O operador de coalescência nula retorna os resultados da expressão de seu lado direito se a expressão de seu lado esquerdo for {{jsxref("null")}} ou {{jsxref("undefined")}}.</p>
+
+<h3 id="Endereçando_um_valor_padrão_à_variável">Endereçando um valor padrão à variável</h3>
+
+<p>Inicialmente, quando se deseja endereçar um valor padrão à variável, um padrão comum é utilizar o operador lógico OR  (<code><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Operadores_Logicos#OR_Lógico_()">||</a></code>):</p>
+
+<pre class="brush: js">let foo;
+
+//  foo nunca é endereçado a nenhum valor, portanto, ainda está indefinido
+let someDummyText = foo || 'Hello!';</pre>
+
+<p>Entretanto, devido ao <code>||</code> ser um operador lógico booleano, o operando do lado esquerdo é coagido para um valor booleano para sua avaliação, e, qualquer valor <em>falseável</em> (<code>0</code>, <code>''</code>, <code>NaN</code>, <code>null</code>, <code>undefined</code>) não é retornado. Este comportamento pode causar consequencias inesperadas se você considerar <code>0</code>, <code>''</code>, or <code>NaN</code> como valores válidos.</p>
+
+<pre class="brush: js">let count = 0;
+let text = "";
+
+let qty = count || 42;
+let message = text || "Olá!";
+console.log(qty);     // 42 e não 0
+console.log(message); // "hi!" e não ""
+</pre>
+
+<p>O operador de coalescência nula evita esta cilada pois retorna o segundo operando apenas quando o primeiro é avaliado entre os valores <code>null</code> ou <code>undefined</code> (mas nehum outro valor falseável):</p>
+
+<pre class="brush: js">let myText = ''; // Uma string vazia (que também é um valor falseável)
+
+let notFalsyText = myText || 'Olá mundo';
+console.log(notFalsyText); // Olá mundo
+
+let preservingFalsy = myText ?? 'Olá vizinhança';
+console.log(preservingFalsy); // '' (Pois myText não é undefined e nem null)
+</pre>
+
+<h3 id="Curto-circuito">Curto-circuito</h3>
+
+<p>Assim como os operadores lógicos OR e AND, a expressão do lado direito não é avaliada se o lado esquerdo não for avaliado entre <code>null</code> e nem <code>undefined</code>.</p>
+
+<pre class="brush: js">function A() { console.log('A foi chamado'); return undefined;}
+function B() { console.log('B foi chamado'); return false;}
+function C() { console.log('C foi chamado'); return "foo";}
+
+console.log( A() ?? C() );
+// Imprime "A foi chamado" então "C foi chamado" e por fim "foo"
+// Como A() retornou undefined então ambas expressões foram avaliadas
+
+console.log( B() ?? C() );
+// Imprime "B foi chamado" então "false"
+// Como B() retornou false (e não null ou undefined), a expressão
+// do lado direito não foi avaliada.
+</pre>
+
+<h3 id="Sem_encadeamento_com_os_operadores_AND_e_OR">Sem encadeamento com os operadores AND e OR</h3>
+
+<p>Não é possível encadear ambos operadores AND (<code>&amp;&amp;</code>) e OR (<code>||</code>) diretamente com o <code>??</code>. Um <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">SyntaxError</a></code> será disparado nesse tipo de caso.</p>
+
+<pre class="brush: js example-bad">null || undefined ?? "foo"; // Dispara um SyntaxError
+true || undefined ?? "foo"; // Dispara um SyntaxError</pre>
+
+<p>Entretanto, explicitar diretamente a precedência por meio de parênteses resulta no comportamento correto:</p>
+
+<pre class="brush: js example-good">(null || undefined) ?? "foo"; // retorna "foo"
+</pre>
+
+<h3 id="Relacionamento_com_o_operador_de_encadeamento_opcional_.">Relacionamento com o operador de encadeamento opcional (<code>?.</code>)</h3>
+
+<p>O operador de coalescêcia nula trata <code>undefined</code> e <code>null</code> como valores específicos e então executa o <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining">operador de encadeamento opcional (<code>?.</code>)</a> o qual é útil para acessar uma propriedade de um objeto, o qual pode ser <code>null</code> ou <code>undefined</code>.</p>
+
+<pre class="brush: js">let foo = { someFooProp: "oi" };
+
+console.log(foo.someFooProp?.toUpperCase());  // "OI"
+console.log(foo.someBarProp?.toUpperCase()); // undefined
+</pre>
+
+<h2 id="Exemplo">Exemplo</h2>
+
+<p>Neste exemplo, nós iremos prover valores padrão, mas manter valores que não sejam (advinha???) <code>null</code> ou <code>undefined</code>.</p>
+
+<pre class="brush: js">const nullValue = null;
+const emptyText = ""; // falseável (falsy)
+const someNumber = 42;
+
+const valA = nullValue ?? "padrão para A";
+const valB = emptyText ?? "padrão para B";
+const valC = someNumber ?? 0;
+
+console.log(valA); // "padrão para A"
+console.log(valB); // "" (pois a string vazia não é null ou undefined)
+console.log(valC); // 42
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><a href="https://tc39.es/proposal-nullish-coalescing/#top">Proposal for the "nullish coalescing" operator</a></td>
+   <td>Stage 4</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+
+
+<p>{{Compat("javascript.operators.nullish_coalescing")}}</p>
+
+<h3 id="Progresso_de_implementação">Progresso de implementação</h3>
+
+<p>A seguinte tabela fornece o status diário de implementação para este recurso, porque este recurso ainda não atingiu a estabilidade entre navegadores. Os dados são gerados pela execução de testes de recursos relevantes no <a href="https://github.com/tc39/test262">Test262</a>, a plataforma de testes padrão do JavaScript, em "edições noturnas", ou último release de cada motor JavaScript dos navegadores.</p>
+
+<div>{{EmbedTest262ReportResultsTable("coalesce-expression")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining">The optional chaining operator</a></li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Operadores_Logicos#OR_Lógico_()">The logical OR (<code>||</code>) operator</a></li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Functions/Parametros_Predefinidos">Default parameters in functions</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/operador_virgula/index.html b/files/pt-br/web/javascript/reference/operators/operador_virgula/index.html
new file mode 100644
index 0000000000..be374104d0
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/operador_virgula/index.html
@@ -0,0 +1,102 @@
+---
+title: Operador Vírgula
+slug: Web/JavaScript/Reference/Operators/Operador_Virgula
+translation_of: Web/JavaScript/Reference/Operators/Comma_Operator
+---
+<div>
+ {{jsSidebar("Operators")}}</div>
+<h2 id="Summary" name="Summary">Sumário</h2>
+<p>o <strong>operador vírgula</strong> avalia o valor de seus operandos (da esquerda para a direita) e retorna o valor do último operando.</p>
+<h2 id="Sintaxe">Sintaxe</h2>
+<pre class="syntaxbox"><em>expr1</em>, <em>expr2, expr3...</em></pre>
+<h2 id="Parameters">Parameters</h2>
+<dl>
+ <dt>
+  <code>expr1</code>, <code>expr2, expr3...</code></dt>
+ <dd>
+  Quaisquer expressões.</dd>
+</dl>
+<h2 id="Descrição">Descrição</h2>
+<p>Você pode usar o operador vírgula quando desejar incluir múltiplas expressões em um lugar que requer uma única expressão. O uso mais comum desse operador é suprir múltiplos parâmetros em um loop <code>for</code>.</p>
+<h2 id="Exemplo">Exemplo</h2>
+<p>Se <code>a</code> é um array de 2 dimensões com 10 elementos de um lado, o seguinte código usa o operador vírgula para incrementar duas variáveis mutuamente. Note que a vírgula na declaração <code>var </code><em><strong>não</strong></em> é o operador vírgula, porque ele não existe dentro de uma expressão. Além disso, ela é uma caractere especial nas declarações <code>var</code> para combinar múltiplas delas em uma única. Embora praticamente a vírgula comporte-se quase que igualmente ao operador vírgula. O código imprime os valores dos elementos diagonais da matriz:</p>
+<pre class="brush:js;highlight:[1]">for (var i = 0, j = 9; i &lt;= 9; i++, j--)
+  document.writeln("a[" + i + "][" + j + "] = " + a[i][j]);
+</pre>
+<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>1ª Edição ECMAScript.</td>
+   <td>Padrão</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.14', 'Comma operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-comma-operator', 'Comma operator')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+<p>{{ CompatibilityTable() }}</p>
+<div id="compat-desktop">
+ <table class="compat-table">
+  <tbody>
+   <tr>
+    <th>Característica</th>
+    <th>Chrome</th>
+    <th>Firefox (Gecko)</th>
+    <th>Internet Explorer</th>
+    <th>Opera</th>
+    <th>Safari</th>
+   </tr>
+   <tr>
+    <td>Suporte Básico</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+   </tr>
+  </tbody>
+ </table>
+</div>
+<div id="compat-mobile">
+ <table class="compat-table">
+  <tbody>
+   <tr>
+    <th>Característica</th>
+    <th>Android</th>
+    <th>Chrome for Android</th>
+    <th>Firefox Mobile (Gecko)</th>
+    <th>IE Mobile</th>
+    <th>Opera Mobile</th>
+    <th>Safari Mobile</th>
+   </tr>
+   <tr>
+    <td>Suporte Básico</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+    <td>{{ CompatVersionUnknown() }}</td>
+   </tr>
+  </tbody>
+ </table>
+</div>
+<h2 id="See_also" name="See_also">Veja também</h2>
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for">for loop</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/operadores_de_comparação/index.html b/files/pt-br/web/javascript/reference/operators/operadores_de_comparação/index.html
new file mode 100644
index 0000000000..c1a7f864ba
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/operadores_de_comparação/index.html
@@ -0,0 +1,250 @@
+---
+title: Operadores de comparação
+slug: Web/JavaScript/Reference/Operators/Operadores_de_comparação
+tags:
+  - Comparando String
+  - Comparação
+  - Igualdade
+  - Operadores
+  - Relacionais
+translation_of: Web/JavaScript/Reference/Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>O JavaScript possui comparações estritas e conversão de tipos. Uma comparação estrita (e.g., <code>===</code>) somente é verdade se os operandos forem do mesmo tipo e de conteúdo correspondente. A comparação abstrata mais comumente utilizada (e.g. <code>==</code>) converte os operandos no mesmo tipo antes da comparação. Para comparações abstratas relacionais (e.g., <code>&lt;=</code>), os operandos são primeiro convertidos em primitivos, depois para o mesmo tipo, depois comparados.</p>
+
+<p>Strings são comparadas baseadas na ordenação lexicografica padrão, usando valores Unicode.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-comparisonoperators.html")}}</div>
+
+<p class="hidden">Os fontes para este exemplo interativo estão em um repositório no GitHub. Se você gostaria de contribuir com projetos de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e envie para nós um pull request.</p>
+
+<p>Características de comparação:</p>
+
+<ul>
+ <li>Duas strings são estritamente iguals quando elas possuem a mesma sequência de caracteres, o mesmo tamanho, Duas string são estritamente iguals quando elas possuem a mesma sequência de caracteres, o mesmo tamanho, e os mesmos caracteres em posições correspondentes.</li>
+ <li>Dois números são estritamente iguais quando eles são numericamente iguais (tem o mesmo valor numérico). <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="NaN">NaN</a> não é igual a nada, incluindo NaN. Zeros positivos e negativos são iguals entre si.</li>
+ <li>Dois operadores Boleanos são estritamente iguais se ambos são <code>true</code> ou ambos são <code>false</code>.</li>
+ <li>Dois objetos distintos nunca são iguais para comparações estritas ou abstratas.</li>
+ <li>Uma expressão comparando Objetos somente é verdadeira se os operandos referenciarem o mesmo Objeto.</li>
+ <li>Os tipo Null e Undefined são estritamente iguais entre eles mesmos e abstratamente iguais entre si.</li>
+</ul>
+
+<h2 id="Operadores_de_Igualdade">Operadores de Igualdade </h2>
+
+<h3 id="Igualdade"><a name="Equality">Igualdade (==)</a></h3>
+
+<p>O operador de igualdade converte o operando se ele <strong>não for do mesmo tipo</strong>, então aplica a comparação estrita. Se <strong>ambos os operandos são objetos</strong>, então o JavaScript compara referencias internas que são iguais quando os operandos se referem ao mesmo objeto em memória.</p>
+
+<h4 id="Sintaxe">Sintaxe</h4>
+
+<pre class="syntaxbox notranslate">x == y
+</pre>
+
+<h4 id="Exemplos">Exemplos</h4>
+
+<pre class="brush: js notranslate">1    ==  1         // verdade
+'1'  ==  1         // verdade
+1    == '1'        // verdade
+0    == false      // verdade
+0    == null       // falso
+var object1 = {'key': 'value'}, object2 = {'key': 'value'};
+object1 == object2 // falso
+0    == undefined  // falso
+null == undefined  // verdade
+</pre>
+
+<h3 id="Desigualdade_!"><a name="Inequality">Desigualdade (!=)</a></h3>
+
+<p>O operador de desigualdade retorna true (verdade) se os operandos não são iguais. Se os dois operandos <strong>não são do mesmo tipo</strong>, o JavaScript tenta converter os operandos para o tipo apropriado para a comparação. Se <strong>ambos os operandos são objetos</strong>, então o JavaScript compara referências internas que não são iguais quando os operandos se referem a objetos diferentes na memória.</p>
+
+<h4 id="Sintaxe_2">Sintaxe</h4>
+
+<pre class="syntaxbox notranslate">x != y</pre>
+
+<h4 id="Exemplos_2">Exemplos</h4>
+
+<pre class="brush: js notranslate">1 !=   2     // verdade
+1 !=  '1'    // falso
+1 !=  "1"    // falso
+1 !=  true   // falso
+0 !=  false  // falso
+</pre>
+
+<h3 id="Identidade_igualdade_estrita"><a name="Identity">Identidade / igualdade estrita (===)</a></h3>
+
+<p>O operador de identidade retorna true (verdade) se os operandos são estritamente iguais (veja acima) <strong>sem conversão de tipo</strong>. </p>
+
+<h4 id="Sintaxe_3">Sintaxe</h4>
+
+<pre class="syntaxbox notranslate">x === y</pre>
+
+<h4 id="Exemplos_3">Exemplos</h4>
+
+<pre class="brush: js  notranslate">3 === 3   // verdade
+3 === '3' // falso
+var object1 = {'key': 'value'}, object2 = {'key': 'value'};
+object1 === object2 //f also</pre>
+
+<h3 id="Non-identity_desigualdade_estrita_!"><a name="Nonidentity">Non-identity / desigualdade estrita (!==)</a></h3>
+
+<p>O operador desigualdade estrita (Non-identity) retorna verdadeiro se os operandos <strong>não são iguais e / ou não são do mesmo tipo</strong>.</p>
+
+<h4 id="Sintaxe_4">Sintaxe</h4>
+
+<pre class="syntaxbox notranslate">x !== y</pre>
+
+<h4 id="Exemplos_4">Exemplos</h4>
+
+<pre class="brush: js notranslate">3 !== '3' // verdade
+4 !== 3   // verdade
+</pre>
+
+<h2 id="Operadores_relacionais">Operadores relacionais</h2>
+
+<p>Cada um desses operadores chamará a função valueOf () em cada operando antes que uma comparação seja feita.</p>
+
+<h3 id="Operador_Maior_>"><a name="Greater_than_operator">Operador Maior (&gt;)</a></h3>
+
+<p>O operador de Maior retorna true se o operando da esquerda for maior que o operando da direita.</p>
+
+<h4 id="Sintaxe_5">Sintaxe</h4>
+
+<pre class="syntaxbox notranslate">x &gt; y</pre>
+
+<h4 id="Exemplos_5">Exemplos</h4>
+
+<pre class="brush: js notranslate">4 &gt; 3 // verdade
+</pre>
+
+<h3 id="Operador_maior_ou_igual_>"><a name="Greater_than_or_equal_operator">Operador maior ou igual (&gt;=)</a></h3>
+
+<p>O operador maior ou igual retorna true se o operando da esquerda for maior ou igual ao operando da direita.</p>
+
+<h4 id="Sintaxe_6">Sintaxe</h4>
+
+<pre class="syntaxbox notranslate"> x &gt;= y</pre>
+
+<h4 id="Exemplos_6">Exemplos</h4>
+
+<pre class="brush: js notranslate">4 &gt;= 3 // verdade
+3 &gt;= 3 // verdade
+</pre>
+
+<h3 id="Operador_Menor_&lt;"><a name="Less_than_operator">Operador Menor (&lt;)</a></h3>
+
+<p>O operador menor retorna true (verdadeiro) se o operando da esquerda for menor que o operando da direita.</p>
+
+<h4 id="Sintaxe_7">Sintaxe</h4>
+
+<pre class="syntaxbox notranslate"> x &lt; y</pre>
+
+<h4 id="Exemplos_7">Exemplos</h4>
+
+<pre class="brush: js notranslate">3 &lt; 4 // verdade
+</pre>
+
+<h3 id="Operador_menor_ou_igual_&lt;"><a id="Less_than_or_equal_operator" name="Less_than_or_equal_operator">Operador menor ou igual (&lt;=)</a></h3>
+
+<p>O operador menor ou igual retorna true (verdadeiro) se o operando da esquerda for menor ou igual ao operando da direita.</p>
+
+<h4 id="Sintaxe_8">Sintaxe</h4>
+
+<pre class="syntaxbox notranslate"> x &lt;= y</pre>
+
+<h4 id="Exemplos_8">Exemplos</h4>
+
+<pre class="brush: js notranslate">3 &lt;= 4 // verdade
+</pre>
+
+<h2 id="Usando_Operadores_de_Igualdade">Usando Operadores de Igualdade</h2>
+
+<p>Os operadores de igualdade padrão (== e! =) Usam o <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3">Algoritmo de Comparação de Igualdade Abstrata</a> </p>
+
+<p>para comparar dois operandos. Se os operandos forem de tipos diferentes, ele tentará convertê-los para o mesmo tipo antes de fazer a comparação. Por exemplo, na expressão 5 == '5', a sequência à direita é convertida em {{jsxref ("Number" )}} antes da comparação ser feita.</p>
+
+<p>Os operadores de igualdade estrita (=== e! ==) usam o <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.6">Algoritmo de comparação estrita de igualdade</a> e se destinam a executar comparações de igualdade em operandos do mesmo tipo. Se os operandos são de tipos diferentes, o resultado é sempre falso, então 5! == '5'.<br>
+ <br>
+ Use operadores de igualdade estrita se os operandos precisarem ser de um tipo específico e também de valor ou se o tipo exato dos operandos for importante. Caso contrário, use os operadores de igualdade padrão, que permitem comparar a identidade de dois operandos, mesmo que não sejam do mesmo tipo.<br>
+ <br>
+ Quando a conversão de tipos está envolvida na comparação (por exemplo, comparação não estrita), o JavaScript converte os tipos {{jsxref ("String")}}, {{jsxref ("Number")}}, {{jsxref ("Booleano" )}} ou {{jsxref ("Object")}}) operandos da seguinte forma:</p>
+
+<ul>
+ <li>Ao comparar um número e uma string, a string é convertida em um valor numérico. JavaScript tenta converter o literal numérico de string em um valor de tipo Number. Primeiro, um valor matemático é derivado do literal numérico da string. Em seguida, esse valor é arredondado para o valor de tipo de número mais próximo.</li>
+ <li>Se um dos operandos for booleano, o operando booleano é convertido em 1 se for verdadeiro e +0 se for falso.</li>
+ <li>Se um objeto é comparado com um número ou string, o JavaScript tenta retornar o valor padrão para o objeto. Os operadores tentam converter o objeto em um valor primitivo, um valor String ou Number, usando os métodos valueOf e toString dos objetos. Se essa tentativa de converter o objeto falhar, será gerado um erro de tempo de execução.</li>
+ <li>Observe que um objeto é convertido em primitivo se, e somente se, seu comparando for um primitivo. Se os dois operandos forem objetos, eles serão comparados como objetos, e o teste de igualdade será verdadeiro apenas se ambos fizerem referência ao mesmo objeto.</li>
+</ul>
+
+<div class="note"><strong>Nota:</strong> Os objetos String são do Tipo Objeto, não String! Os objetos de string raramente são usados, portanto, os seguintes resultados podem ser surpreendentes:</div>
+
+<pre class="brush:js notranslate">// true, pois ambos os operandos são do tipo String (ou seja, primitivos de string):
+'foo' === 'foo'
+
+var a = new String('foo');
+var b = new String('foo');
+
+// falso (false) pois a e b, embora do tipo "Objeto", são instâncias diferentes
+a == b
+
+// falso (false) pois a e b, embora do tipo "Objeto", são instâncias diferentes
+a === b
+
+// verdadeiro (true) pois o objeto a e 'foo' (String) são de tipos diferentes e, o Objeto (a)
+// é convertido para String ('foo') antes da comparação
+a == 'foo'</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('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição Inicial. Implementado em JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Adicionandos os operadores <code>===</code> e <code>!==</code> . Implementado em JavaScript 1.3</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.8')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definidos em várias seções das especificações: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Operadores Relacionais </a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdade</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-relational-operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definidos em várias seções das especificações: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Operadores Relacionais </a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdade</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-relational-operators')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definidos em várias seções das especificações: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.8">Operadores Relacionais </a>, <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-11.9">Operadores de Igualdade</a></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatilidade_entre_navegadores">Compatilidade entre navegadores</h2>
+
+<div class="hidden">A tabela de compatibilidade desta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos uma solicitação de recebimento.</div>
+
+<p>{{Compat("javascript.operators.comparison")}}</p>
+
+<h2 id="Consulte_também">Consulte também</h2>
+
+<ul>
+ <li>{{jsxref("Object.is()")}}</li>
+ <li>{{jsxref("Math.sign()")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Equality_comparisons_and_sameness">Comparações de igualdade e similaridades</a></li>
+</ul>
+
+<div id="gtx-trans" style="position: absolute; left: 32px; top: 2185.4px;">
+<div class="gtx-trans-icon"></div>
+</div>
diff --git a/files/pt-br/web/javascript/reference/operators/operadores_logicos/index.html b/files/pt-br/web/javascript/reference/operators/operadores_logicos/index.html
new file mode 100644
index 0000000000..7c6c4f6aef
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/operadores_logicos/index.html
@@ -0,0 +1,342 @@
+---
+title: Operadores Lógicos
+slug: Web/JavaScript/Reference/Operators/Operadores_Logicos
+tags:
+  - Operador
+  - Operadores lógicos
+  - Referencia
+  - e
+  - não
+  - ou
+translation_of: Web/JavaScript/Reference/Operators
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>Operadores lógicos são tipicamente usados com valores <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean">Booleanos</a></code> (lógicos). Quando eles o são, retornam um valor booleano. Porém, os operadores <code>&amp;&amp;</code> e <code>||</code> de fato retornam o valor de um dos operandos especificos, então se esses operadores são usados com valores não booleanos, eles podem retornar um valor não booleano.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Os operadores lógicos são descritos na tabela abaixo:</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <th>Operador</th>
+   <th>Utilização</th>
+   <th>Descrição</th>
+  </tr>
+  <tr>
+   <td>Logical AND (<code>&amp;&amp;</code>)</td>
+   <td><code><em>expr1</em> &amp;&amp; <em>expr2</em></code></td>
+   <td>Retorna <code>expr1</code> se essa pode ser convertido para <code>falso</code>; senão, retorna <code>expr2</code>. Dessa forma, quando usado para valores Booleanos, <code>&amp;&amp;</code> retorna <code>verdadeiro</code> se ambos os operandos forem <code>verdadeiro</code> ; senão, retorna <code>falso</code>.</td>
+  </tr>
+  <tr>
+   <td>Logical OR (<code>||</code>)</td>
+   <td><code><em>expr1</em> || <em>expr2</em></code></td>
+   <td>Retorna <code>expr1</code> se essa pode ser convertido para <code>verdadeiro</code>; senão, retorna <code>expr2</code>. Dessa forma, quando usado para valores Booleanos, <code>||</code> retorna <code>verdadeiro</code> se qualquer dos operandos for <code>verdadeiro</code>; se ambos são <code>falso</code>, retorna <code>falso</code>.</td>
+  </tr>
+  <tr>
+   <td>Logical NOT (<code>!</code>)</td>
+   <td><code>!<em>expr</em></code></td>
+   <td>
+    <p>Retorna <code>falso</code>se o seu operando pode ser convertido para verdadeiro; senão, retorna <code>verdadeiro</code>.</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<p>Se um valor pode ser convertido para <code>verdadeiro</code>, este valor é chamado de {{Glossary("truthy")}}. Se um valor pode ser convertido para <code>falso</code>, este valor é chamado de {{Glossary("falsy")}}.</p>
+
+<p>Exemplos de expressões que podem ser convertidas para falso são:</p>
+
+<ul>
+ <li><code>null</code>;</li>
+ <li><code>NaN;</code></li>
+ <li><code>0</code>;</li>
+ <li>string vazia (<code>""</code>); </li>
+ <li><code>undefined</code>.</li>
+</ul>
+
+<p>Mesmo que os operadores <code>&amp;&amp;</code> and <code>||</code> possam ser utilizados com operandos que não são valores Booleanos, eles ainda podem ser considerados como operadores booleanos visto que seus valores de saída sempre podem ser convertidos em valores booleanos.</p>
+
+<h3 id="Short-Circuit_Evaluation" name="Short-Circuit_Evaluation">Avaliação de Curto-Circuito (Short-Circuit) </h3>
+
+<p>Como as expressões lógicas são avaliadas da esquerda pra direita, elas são testadas para possível avaliação de "curto-circuito" ("short-circuit") utilizando as seguintes regras:</p>
+
+<ul>
+ <li><code>falso &amp;&amp; (<em>qualquer coisa)</em></code><em>  </em>é avaliado como falso através de curto-circuito.</li>
+ <li><code>true || (<em>qualquer coisa)</em></code><em> </em>é avaliado como verdadeiro através de curto-circuito.</li>
+</ul>
+
+<p>As regras de lógica garantem que essas avaliações estejam sempre corretas. Repare que a porção <em>qualquer coisa</em> das expressões acima não é avaliada, logo qualquer problema oriundo de tê-lo feito não é consumado. Note também  que a parte<em> qualquer coisa</em> das expressões acima pode ser qualquer expressão lógica unitária (conforme é indicado pelos <span style="line-height: 1.5;">parênteses</span>).</p>
+
+<p>Por exemplo, as duas funções a seguir são equivalentes.</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="keyword token">function</span> <span class="function token">shortCircuitEvaluation</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+  <span class="comment token">// logical OR (||)</span>
+  <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">||</span> <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+
+  <span class="comment token">// logical AND (&amp;&amp;)</span>
+  <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="operator token">&amp;&amp;</span> <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+<span class="punctuation token">}</span>
+
+<span class="keyword token">function</span> <span class="function token">equivalentEvaluation</span><span class="punctuation token">(</span><span class="punctuation token">)</span> <span class="punctuation token">{</span>
+
+  <span class="comment token">// logical OR (||)</span>
+  <span class="keyword token">var</span> orFlag <span class="operator token">=</span> <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+  <span class="keyword token">if</span> <span class="punctuation token">(</span><span class="operator token">!</span>orFlag<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+  <span class="punctuation token">}</span>
+
+
+  <span class="comment token">// logical AND (&amp;&amp;)</span>
+  <span class="keyword token">var</span> andFlag <span class="operator token">=</span> <span class="function token">doSomething</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+  <span class="keyword token">if</span> <span class="punctuation token">(</span>andFlag<span class="punctuation token">)</span> <span class="punctuation token">{</span>
+    <span class="function token">doSomethingElse</span><span class="punctuation token">(</span><span class="punctuation token">)</span><span class="punctuation token">;</span>
+  <span class="punctuation token">}</span>
+<span class="punctuation token">}</span></code></pre>
+
+<p>Contudo, as expressões a seguir não são equivalentes, devido <span style="line-height: 1.5;">a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence">precedência do operador</a>, e reforçam a importância de que o operador do lado direito (right hand) seja uma única expressão (agrupada com o uso de parênteses, caso seja necessário)</span><span style="line-height: 1.5;">.</span></p>
+
+<pre class="brush: js"> false &amp;&amp; true || true       // retorna true
+ false &amp;&amp; (true || true)     // retorna falso</pre>
+
+<h3 id="Logical_AND_.28.29" name="Logical_AND_.28&amp;&amp;.29"><a name="Logical_AND">AND Lógico (<code>&amp;&amp;</code>)</a></h3>
+
+<p>O código a seguir demonstra exemplos do operador <code>&amp;&amp;</code> (AND lógico). </p>
+
+<pre class="brush: js">a1 = true  &amp;&amp; true       // t &amp;&amp; t retorna true
+a2 = true  &amp;&amp; false      // t &amp;&amp; f retorna false
+a3 = false &amp;&amp; true       // f &amp;&amp; t retorna false
+a4 = false &amp;&amp; (3 == 4)   // f &amp;&amp; f retorna false
+a5 = 'Cat' &amp;&amp; 'Dog'      // t &amp;&amp; t retorna "Dog"
+a6 = false &amp;&amp; 'Cat'      // f &amp;&amp; t retorna false
+a7 = 'Cat' &amp;&amp; false      // t &amp;&amp; f retorna false
+a8 = ''    &amp;&amp; false      // f &amp;&amp; f retorna ""
+a9 = false &amp;&amp; ''         // f &amp;&amp; t retorna false
+</pre>
+
+<h3 id="OR_Lógico_()"><a name="Logical_OR">OR Lógico (<code>||</code>)</a></h3>
+
+<p>O código a seguir demonstra exemplos do operador <code>||</code> (OR lógico).</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js">o1 <span class="operator token">=</span> <span class="keyword token">true</span>  <span class="operator token">||</span> <span class="keyword token">true</span>       <span class="comment token">// t || t retorna true</span>
+o2 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="keyword token">true</span>       <span class="comment token">// f || t retorna true</span>
+o3 <span class="operator token">=</span> <span class="keyword token">true</span>  <span class="operator token">||</span> <span class="keyword token">false</span>      <span class="comment token">// t || f retorna true</span>
+o4 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="punctuation token">(</span><span class="number token">3</span> <span class="operator token">==</span> <span class="number token">4</span><span class="punctuation token">)</span>   <span class="comment token">// f || f retorna false</span>
+o5 <span class="operator token">=</span> <span class="string token">'Cat'</span> <span class="operator token">||</span> <span class="string token">'Dog'</span>      <span class="comment token">// t || t retorna "Cat"</span>
+o6 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="string token">'Cat'</span>      <span class="comment token">// f || t retorna "Cat"</span>
+o7 <span class="operator token">=</span> <span class="string token">'Cat'</span> <span class="operator token">||</span> <span class="keyword token">false</span>      <span class="comment token">// t || f retorna "Cat"</span>
+o8 <span class="operator token">=</span> <span class="string token">''</span>    <span class="operator token">||</span> <span class="keyword token">false</span>      <span class="comment token">// f || f retorna false</span>
+o9 <span class="operator token">=</span> <span class="keyword token">false</span> <span class="operator token">||</span> <span class="string token">''</span>         <span class="comment token">// f || f retorna ""</span></code></pre>
+
+<h3 id="Logical_NOT_.28.21.29" name="Logical_NOT_.28.21.29"><a name="Logical_NOT">NOT Logico (<code>!</code>)</a></h3>
+
+<p>O código a seguir demonstra exemplos do operador <code>!</code> (NOT lógico) .</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js">n1 <span class="operator token">=</span> <span class="operator token">!</span><span class="keyword token">true</span>               <span class="comment token">// !t returns false</span>
+n2 <span class="operator token">=</span> <span class="operator token">!</span><span class="keyword token">false</span>              <span class="comment token">// !f returns true</span>
+n3 <span class="operator token">=</span> <span class="operator token">!</span><span class="string token">'Cat'</span>              <span class="comment token">// !t returns false</span></code></pre>
+
+<h3 id="Regras_de_conversão">Regras de conversão</h3>
+
+<h4 id="Convertendo_AND_para_OR">Convertendo AND para OR</h4>
+
+<p>A operação a seguir, envolvendo Booleanos:</p>
+
+<pre class="brush: js">bCondition1 &amp;&amp; bCondition2</pre>
+
+<p>é sempre igual a:</p>
+
+<pre class="brush: js">!(!bCondition1 || !bCondition2)</pre>
+
+<h4 id="Convertendo_OR_to_AND">Convertendo OR to AND</h4>
+
+<p>A operação a seguir, envolvendo Booleanos:</p>
+
+<pre class="brush: js">bCondition1 || bCondition2</pre>
+
+<p>é sempre igual a:</p>
+
+<pre class="brush: js">!(!bCondition1 &amp;&amp; !bCondition2)</pre>
+
+<h4 id="Convertendo_entre_dois_NOT">Convertendo entre dois NOT</h4>
+
+<p>A seguinte operação envolvendo Booleanos:</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js"><span class="operator token">!</span><span class="operator token">!</span>bCondition</code></pre>
+
+<p>é sempre igual a:</p>
+
+<pre class="brush: js line-numbers  language-js"><code class="language-js">bCondition</code></pre>
+
+<h3 id="Removendo_parenteses_aninhados">Removendo parenteses aninhados</h3>
+
+<p>Como as expressões lógicas são avaliadas da esquerda pra direita, é sempre possível remover os parênteses de uma expressão complexa seguindo algumas regras:</p>
+
+<h4 id="Removendo_AND_aninhado">Removendo AND aninhado</h4>
+
+<p>A seguinte operação composta envolvendo Booleanos:</p>
+
+<pre class="brush: js">bCondition1 || (bCondition2 &amp;&amp; bCondition3)</pre>
+
+<p>é igual a :</p>
+
+<pre class="brush: js">bCondition1 || bCondition2 &amp;&amp; bCondition3</pre>
+
+<h4 id="Removendo_OR_aninhado">Removendo OR aninhado</h4>
+
+<p>A operação composta a seguir, envolvendo Booleanos:</p>
+
+<pre class="brush: js">bCondition1 &amp;&amp; (bCondition2 || bCondition3)</pre>
+
+<p>é sempre igual a:</p>
+
+<pre class="brush: js">!(!bCondition1 || !bCondition2 &amp;&amp; !bCondition3)</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estatus</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1st Edition.</td>
+   <td>Standard</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.4.9', 'Logical NOT Operator')}}<br>
+    {{SpecName('ES5.1', '#sec-11.11', 'Binary Logical Operators')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-logical-not-operator', 'Logical NOT operator')}}<br>
+    {{SpecName('ES6', '#sec-binary-logical-operators', 'Binary Logical Operators')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_o_Navegador">Compatibilidade com o Navegador</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Recurso</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td><a href="#Logical_AND">Logical AND (<code>&amp;&amp;</code>)</a></td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+  <tr>
+   <td><a href="#Logical_OR">Logical OR (<code>||</code>)</a></td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+  <tr>
+   <td><a href="#Logical_NOT">Logical NOT (<code>!</code>)</a></td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td><a href="#Logical_AND">Logical AND (<code>&amp;&amp;</code>)</a></td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+  <tr>
+   <td><a href="#Logical_OR">Logical OR (<code>||</code>)</a></td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+  <tr>
+   <td><a href="#Logical_NOT">Logical NOT (<code>!</code>)</a></td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="JavaScript_1.0_and_1.1" name="JavaScript_1.0_and_1.1">Retrocompatibilidade: Comportamento no  JavaScript 1.0 e1.1</h3>
+
+<p>Os operadores  &amp;&amp; and <code>|| se comportam da seguinte maneira:</code></p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <th>Operador</th>
+   <th>Utilização</th>
+   <th>Comportamento</th>
+  </tr>
+  <tr>
+   <td><code>&amp;&amp;</code></td>
+   <td><code><em>expr1</em> &amp;&amp; <em>expr2</em></code></td>
+   <td>Se o primeiro operando (<code>expr1</code>) pode ser convertido para falso, o operador <code>&amp;&amp; </code> retorna false ao invés do valor do <code>expr1</code>.</td>
+  </tr>
+  <tr>
+   <td><code>||</code></td>
+   <td><code><em>expr1</em> || <em>expr2</em></code></td>
+   <td>If the first operand (<code>expr1</code>) can be converted to true, the <code>||</code> operator retorna true rather than the value of <code>expr1</code>.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="See_also" name="See_also">Veja Também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">Bitwise operators</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/operator_precedence/index.html b/files/pt-br/web/javascript/reference/operators/operator_precedence/index.html
new file mode 100644
index 0000000000..474dd3e536
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/operator_precedence/index.html
@@ -0,0 +1,343 @@
+---
+title: Precedência de Operadores
+slug: Web/JavaScript/Reference/Operators/Operator_Precedence
+tags:
+  - JavaScript
+  - precedência de operadores
+translation_of: Web/JavaScript/Reference/Operators/Operator_Precedence
+---
+<div>
+<div>{{jsSidebar("Operators")}}</div>
+</div>
+
+<h2 id="Resumo">Resumo</h2>
+
+<p><span class="seoSummary">A precedência de operadores determina a ordem em que os operadores são processados. Operadores com maior precedência são processados primeiro.</span></p>
+
+<p>Um exe<span style="line-height: 1.5;">mplo simples:</span></p>
+
+<pre>3 + 4 * 5 // returns 23
+</pre>
+
+<p>O operador de multiplicação ("<code>*</code>") tem maior precedência que o operador de adição ("<code>+</code>") e por isso será executado primeiro.</p>
+
+<h2 id="Associativity" name="Associativity">Associatividade</h2>
+
+<p>Associatividade determina a ordem em que operadores da mesma precedência são processados. Por exemplo, considere a expressão:</p>
+
+<pre>a OP b OP c
+</pre>
+
+<p>Associatividade à esquerda (esquerda para direita) significa que a expressão será processada como <code>(a OP b) OP c</code>, enquanto associatividade à direita (direita para esquerda) significa que será interpretada como <code>a OP (b OP c)</code>. Operadores de atribuição são associativos à direita, então você pode escrever:</p>
+
+<pre>a = b = 5; 5 = b = a
+</pre>
+
+<p>com o resultado esperado que <code>a</code> e <code>b</code> tenham o valor 5. Isto é porque o operador de atribuição retorna o valor que ele atribuiu. Primeiro, <code>b</code> é definido com o valor 5. Então <code>a</code> é definido com o valor de <code>b</code>.</p>
+
+<h2 id="Table" name="Table">Tabela</h2>
+
+<p>A tabela seguinte está ordenada da mais alta (20) para a mais baixa (0) precedência.</p>
+
+<table class="fullwidth-table">
+ <tbody>
+  <tr>
+   <th>Precedência</th>
+   <th>Tipo do Operador</th>
+   <th>Associatividade</th>
+   <th>Operadores individuais</th>
+  </tr>
+  <tr>
+   <td>20</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Grouping">Agrupamento</a></td>
+   <td>n/a</td>
+   <td><code>( … )</code></td>
+  </tr>
+  <tr>
+   <td rowspan="3">19</td>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors#Dot_notation">Acesso a Membro</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… . …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors#Dot_notation">Acesso a Membro Computado</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… [ … ]</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/JavaScript/Reference/Operators/Special/new" title="JavaScript/Reference/Operators/Special_Operators/new_Operator">new</a> (com lista de argumentos)</td>
+   <td>n/a</td>
+   <td><code>new … ( … )</code></td>
+  </tr>
+  <tr>
+   <td rowspan="2">18</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Guide/Functions" title="JavaScript/Reference/Operators/Special_Operators/function_call">Chamada a Função</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… ( <var>… </var>)</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new" title="JavaScript/Reference/Operators/Special_Operators/new_Operator">new</a> (sem lista de argumentos)</td>
+   <td>direita para esquerda</td>
+   <td><code>new …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="2">17</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment" title="JavaScript/Reference/Operators/Arithmetic_Operators">Incremento Pós-fixado</a></td>
+   <td>n/a</td>
+   <td><code>… ++</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement" title="JavaScript/Reference/Operators/Arithmetic_Operators">Decremento Pós-fixado</a></td>
+   <td>n/a</td>
+   <td><code>… --</code></td>
+  </tr>
+  <tr>
+   <td rowspan="9">16</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_NOT" title="JavaScript/Reference/Operators/Logical_Operators">NÃO lógico</a></td>
+   <td>direita para esquerda</td>
+   <td><code>! …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_NOT" title="JavaScript/Reference/Operators/Bitwise_Operators">NÃO bit-a-bit</a></td>
+   <td>direita para esquerda</td>
+   <td><code>~ …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_plus" title="JavaScript/Reference/Operators/Arithmetic_Operators">Positivo Unário</a></td>
+   <td>direita para esquerda</td>
+   <td><code>+ …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_negation" title="JavaScript/Reference/Operators/Arithmetic_Operators">Negativo Unário</a></td>
+   <td>direita para esquerda</td>
+   <td><code>- …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Increment" title="JavaScript/Reference/Operators/Arithmetic_Operators">Incremento Pré-fixado</a></td>
+   <td>direita para esquerda</td>
+   <td><code>++ …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Decrement" title="JavaScript/Reference/Operators/Arithmetic_Operators">Decremento Pré-fixado</a></td>
+   <td>direita para esquerda</td>
+   <td><code>-- …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/typeof" title="JavaScript/Reference/Operators/Special_Operators/typeof_Operator">typeof</a></td>
+   <td>direita para esquerda</td>
+   <td><code>typeof …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/void" title="JavaScript/Reference/Operators/Special_Operators/void_Operator">void</a></td>
+   <td>direita para esquerda</td>
+   <td><code>void …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete" title="JavaScript/Reference/Operators/Special_Operators/delete_Operator">delete</a></td>
+   <td>direita para esquerda</td>
+   <td><code>delete …</code></td>
+  </tr>
+  <tr>
+   <td>15</td>
+   <td>
+    <p><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Exponentiation">Exponenciação</a></p>
+   </td>
+   <td>direita para esquerda</td>
+   <td>… ** …</td>
+  </tr>
+  <tr>
+   <td rowspan="3">14</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Multiplication" title="JavaScript/Reference/Operators/Arithmetic_Operators">Multiplicação</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… * …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Division" title="JavaScript/Reference/Operators/Arithmetic_Operators">Divisão</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… / …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Remainder" title="JavaScript/Reference/Operators/Arithmetic_Operators">Resto</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… % …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="2">13</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition" title="JavaScript/Reference/Operators/Arithmetic_Operators">Adição</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… + …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Subtraction" title="JavaScript/Reference/Operators/Arithmetic_Operators">Subtração</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… - …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="3">12</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="JavaScript/Reference/Operators/Bitwise_Operators">Deslocamento de bits para esquerda</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… &lt;&lt; …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="JavaScript/Reference/Operators/Bitwise_Operators">Deslocamento de bits para direita</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… &gt;&gt; …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="JavaScript/Reference/Operators/Bitwise_Operators">Deslocamento de bits para direita, sem sinal</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… &gt;&gt;&gt; …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="6">11</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Menor Que</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… &lt; …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Less_than__or_equal_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Menor ou Igual a</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… &lt;= …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Greater_than_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Maior Que</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… &gt; …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Greater_than_or_equal_operator" title="JavaScript/Reference/Operators/Comparison_Operators">Maior ou Igual a</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… &gt;= …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/in" title="JavaScript/Reference/Operators/Special_Operators/in_Operator">in</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… in …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/instanceof" title="JavaScript/Reference/Operators/Special_Operators/instanceof_Operator">instanceof</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… instanceof …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="4">10</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Equality" title="JavaScript/Reference/Operators/Comparison_Operators">Igualdade</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… == …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Inequality" title="JavaScript/Reference/Operators/Comparison_Operators">Desigualdade</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… != …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Identity" title="JavaScript/Reference/Operators/Comparison_Operators">Igualdade Estrita</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… === …</code></td>
+  </tr>
+  <tr>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators#Nonidentity" title="JavaScript/Reference/Operators/Comparison_Operators">Desigualdade Estrita</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… !== …</code></td>
+  </tr>
+  <tr>
+   <td>9</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_AND" title="JavaScript/Reference/Operators/Bitwise_Operators">E bit-a-bit</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… &amp; …</code></td>
+  </tr>
+  <tr>
+   <td>8</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_XOR" title="JavaScript/Reference/Operators/Bitwise_Operators">OU exclusivo bit-a-bit</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… ^ …</code></td>
+  </tr>
+  <tr>
+   <td>7</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators#Bitwise_OR" title="JavaScript/Reference/Operators/Bitwise_Operators">OU bit-a-bit</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… | …</code></td>
+  </tr>
+  <tr>
+   <td>6</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_AND" title="JavaScript/Reference/Operators/Logical_Operators">E lógico</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… &amp;&amp; …</code></td>
+  </tr>
+  <tr>
+   <td>5</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators#Logical_OR" title="JavaScript/Reference/Operators/Logical_Operators">OU lógico</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… || …</code></td>
+  </tr>
+  <tr>
+   <td>4</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Conditional_Operator" title="JavaScript/Reference/Operators/Special_Operators/Conditional_Operator">Condicional</a></td>
+   <td>direita para esquerda</td>
+   <td><code>… ? … : …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="12">3</td>
+   <td rowspan="12"><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Assignment_Operators" title="JavaScript/Reference/Operators/Assignment_Operators">Atribuição</a></td>
+   <td rowspan="12">direita para esquerda</td>
+   <td><code>… = …</code></td>
+  </tr>
+  <tr>
+   <td><code>… += …</code></td>
+  </tr>
+  <tr>
+   <td><code>… -= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… *= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… /= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… %= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… &lt;&lt;= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… &gt;&gt;= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… &gt;&gt;&gt;= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… &amp;= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… ^= …</code></td>
+  </tr>
+  <tr>
+   <td><code>… |= …</code></td>
+  </tr>
+  <tr>
+   <td rowspan="2">2</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/yield" title="JavaScript/Reference/Operators/yield">yield</a></td>
+   <td rowspan="2">direita para esquerda</td>
+   <td><code>yield …</code></td>
+  </tr>
+  <tr>
+   <td><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield*">yield*</a></td>
+   <td><code>yield* …</code></td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator" title="JavaScript/Reference/Operators/Spread_operator">Propagação</a></td>
+   <td>n/a</td>
+   <td><code>...</code> …</td>
+  </tr>
+  <tr>
+   <td>0</td>
+   <td><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comma_Operator" title="JavaScript/Reference/Operators/Comma_Operator">Vírgula / Sequência</a></td>
+   <td>esquerda para direita</td>
+   <td><code>… , …</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<p> </p>
diff --git a/files/pt-br/web/javascript/reference/operators/optional_chaining/index.html b/files/pt-br/web/javascript/reference/operators/optional_chaining/index.html
new file mode 100644
index 0000000000..f3ed1042fa
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/optional_chaining/index.html
@@ -0,0 +1,192 @@
+---
+title: Encadeamento opcional
+slug: Web/JavaScript/Reference/Operators/Optional_chaining
+translation_of: Web/JavaScript/Reference/Operators/Optional_chaining
+---
+<div>{{JSSidebar("Operators")}}</div>
+
+<p>O operador de <strong>encadeamento opcional</strong> <strong><code>?.</code></strong> permite a leitura do valor de uma propriedade localizada internamente em uma cadeia de objetos conectados, sem que a validação de cada referência da cadeia seja expressivamente realizada.</p>
+
+<p>O operador <strong><code>?.</code></strong> funciona de maneira similar ao operador <span class="seoSummary"><code>.</code> de encadeament, exceto que, ao invés de causar um erro se a referência é <a href="/en-US/docs/Glossary/nullish">nullish</a> ({{JSxRef("null")}} ou {{JSxRef("undefined")}}), a expressão sofre um "curto-circuito" e retorna com um valor de <code>undefined</code>.</span> Quando utilizado com uma chamada de função, retorna <code>undefined</code> se a função executada não existir.</p>
+
+<p>Isso resulta em expressões mais curtas e simples ao acessar propriedades encadeadas quando a possibilidade de uma referência ser inexistente. Isso também pode auxiliar ao explorar o conteúdo de um objeto quando não existe garantia da existência de determinadas propriedades obrigatórias.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-optionalchainingoperator.html", "taller")}}</div>
+
+<div class="hidden">A fonte desse exemplo interativo está armazenada em um repositório no GitHub. Se você gostaria de contribuir para esses exemplos interativos, por favor, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate"><var>obj.val</var>?.<var>prop</var>
+<var>obj.val</var>?.[<var>expr</var>]
+<em>obj.arr</em>?.[<var>index</var>]
+<var>obj.func</var>?.(<var>args</var>)
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O operador de encadeamento opcional provê uma forma de simplificar o acesso a valores através de objetos conectados, quando é possível que uma referência ou função possa ser <code>undefined</code> ou <code>null</code>.</p>
+
+<p>Por exemplo, considere um objeto <code>obj</code> que possui uma estrutura aninhada. Sem o encadeamento opcional, verificar proriedades profundamente aninhadas requer uma validação de referências intermediárias, algo como:</p>
+
+<pre class="brush: js notranslate">let nestedProp = obj.first &amp;&amp; obj.first.second;</pre>
+
+<p>O valor de <code>obj.first</code> é confirmadamente não-<code>null</code> (e não-<code>undefined</code>) antes de acessar o valor de <code>obj.first.second</code>. Isso previne o erro que ocorreria se você simplesmente acessasse <code>obj.first.second</code> diretamente sem testar <code>obj.first</code>.</p>
+
+<p>Com o operador de encadeamento opcional (<code>?.</code>), entretanto, você não precisa explicitamente testar e aplicar curto-circuito baseado no estado de <code>obj.first</code> antes de tentar acessar <code>obj.first.second</code>:</p>
+
+<pre class="brush: js notranslate">let nestedProp = obj.first?.second;</pre>
+
+<p>Ao utilizar o operador <code>?.</code> ao invés de apenas <code>.</code>, o JavaScript sabe que deve implicitamente checar e ter certeza que <code>obj.first</code> não é <code>null</code> ou <code>undefined</code> antes de tentar acessar <code>obj.first.second</code>. Se <code>obj.first</code> é <code>null</code> ou <code>undefined</code>, a expressão automaticamente sofrerá curto-circuito, retornando <code>undefined</code>.</p>
+
+<p>Isso é equivalente ao seguinte, exceto que a variável temporária, de fato, não é criada:</p>
+
+<pre class="brush: js notranslate">let temp = obj.first;
+let nestedProp = ((temp === null || temp === undefined) ? undefined : temp.second);
+</pre>
+
+<h3 id="Encadeamento_opcional_com_chamadas_de_funções">Encadeamento opcional com chamadas de funções</h3>
+
+<p>Você pode usar o encadeamento opcional ao tentar chamar um método que pode não existir. Isso pode auxiliar, por exemplo, ao utilizar uma API em que o método está indisponível, seja pela época da implementação ou por causa de uma funcionalidade que ainda não está disponível no dispositivo do usuário.</p>
+
+<p>Usar encadeamento opcional com chamadas de função faz com que a expressão automaticamente retorne <code>undefined</code> ai invés de lançar uma exceção se o método não é encontrado:</p>
+
+<pre class="brush: js notranslate">let result = someInterface.customMethod?.();</pre>
+
+<div class="blockIndicator note">
+<p><strong>Note:</strong> Se existe uma propriedade com tal nome e que não é uma função, usando <code>?.</code> ainda lançará a exceção {{JSxRef("TypeError")}} (<code>x.y</code><code> is not a function</code>).</p>
+</div>
+
+<h4 id="Lidando_com_callbacks_opcionais_ou_manipuladores_de_eventos">Lidando com callbacks opcionais ou manipuladores de eventos</h4>
+
+<p>Se você usa callbacks ou consulta métodos de objetos com <a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/Atribuicao_via_desestruturacao#Object_destructuring">atribuição via desestruturação</a>, você pode ter valores não-existentes que você não conseguirá chamar como funções, a menos que você tenha testado sua existência. Usando <code>?.</code>, você pode evitar esse teste extra:</p>
+
+<pre class="brush: js notranslate">// Escrito como ES2019
+function doSomething(onContent, onError) {
+  try {
+    // ... faz algo com os dados
+  }
+  catch (err) {
+    if (onError) { // teste se onError realmente existe
+      onError(err.message);
+    }
+  }
+}
+</pre>
+
+<pre class="brush: js notranslate">// Usando encadeamento opcional com chamadas de função
+function doSomething(onContent, onError) {
+  try {
+   // ... faz algo com os dados
+  }
+  catch (err) {
+    onError?.(err.message); // Nenhuma exceção se onError for undefined
+  }
+}
+</pre>
+
+<h3 id="Encadeamento_opcional_com_expressões">Encadeamento opcional com expressões</h3>
+
+<p>Você também pode usar o operador de encadeamento opcional ao acessar propriedades com uma expressão usando <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Property_Accessors#Bracket_notation">assessores de propriedade</a>:</p>
+
+<pre class="brush: js notranslate">let nestedProp = obj?.['prop' + 'Name'];
+</pre>
+
+<h3 id="Encadeamento_opcional_não_valid_no_lado_esquerdo_de_uma_atribuição">Encadeamento opcional não valid no lado esquerdo de uma atribuição</h3>
+
+<pre class="brush: js notranslate"><code>let object = {};
+object?.property = 1; // Uncaught SyntaxError: Invalid left-hand side in assignment</code></pre>
+
+<h3 id="Acesso_a_item_de_Array_com_encadeamento_opcional">Acesso a item de Array com encadeamento opcional</h3>
+
+<pre class="brush: js notranslate">let arrayItem = arr?.[42];</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_básico">Exemplo básico</h3>
+
+<p>Esse exemplo busca plo valor da propriedade <code>name</code> para o membro <code>bar</code> em um map quando não existe tal membro. Portanto, o resultado é <code>undefined</code>.</p>
+
+<pre class="brush: js notranslate">let myMap = new Map();
+myMap.set("foo", {name: "baz", desc: "inga"});
+
+let nameBar = myMap.get("bar")?.name;</pre>
+
+<h3 id="Avaliação_com_curto-circuito">Avaliação com curto-circuito</h3>
+
+<p>Ao usar o encadeamento opcional com expressões, se o operador do lado esquerdo é <code>null</code> ou <code>undefined</code>, a expressão não será avaliada. Por exemplo:</p>
+
+<pre class="brush: js notranslate">let potentiallyNullObj = null;
+let x = 0;
+let prop = potentiallyNullObj?.[x++];
+
+console.log(x); // 0 já que x não foi incrementado
+</pre>
+
+<h3 id="Empilhando_o_operator_de_encadeamento_opcional">Empilhando o operator de encadeamento opcional</h3>
+
+<p>Com estruturadas aninhadas, é possível usar encadeamento opcional múltiplas vezes:</p>
+
+<pre class="brush: js notranslate">let customer = {
+  name: "Carl",
+  details: {
+    age: 82,
+    location: "Paradise Falls" // endereço detalhado é desconhecido
+  }
+};
+let customerCity = customer.details?.address?.city;
+
+// … isso também funcional com encadeamento opcional em chamada de função
+let duration = vacations.trip?.getTime?.();
+</pre>
+
+<h3 id="Combinando_com_o_operador_de_coalescência_nula_nullish_coalescing">Combinando com o operador de coalescência nula (nullish coalescing)</h3>
+
+<p>O {{JSxRef("Operators/Nullish_Coalescing_Operator", "operador de coalescência nula", '', 1)}} pode ser usado após o encadeamento opcional, para construir um valor padrão quando nada é encontrado:</p>
+
+<pre class="brush: js notranslate">let customer = {
+  name: "Carl",
+  details: { age: 82 }
+};
+const customerCity = customer?.city ?? "Cidade desconhecida";
+console.log(customerCity); // Cidade desconhecida</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><a href="https://tc39.es/proposal-optional-chaining/#sec-scope">Proposal for the "optional chaining" operator</a></td>
+   <td>Stage 4</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.operators.optional_chaining")}}</p>
+</div>
+
+<h3 id="Progresso_de_implementação">Progresso de implementação</h3>
+
+<p>The following table provides a daily implementation status for this feature, because this feature has not yet reached cross-browser stability. The data is generated by running the relevant feature tests in <a href="https://github.com/tc39/test262">Test262</a>, the standard test suite of JavaScript, in the nightly build, or latest release of each browser's JavaScript engine.</p>
+
+<div>{{EmbedTest262ReportResultsTable("optional-chaining")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>O {{JSxRef("Operators/Nullish_Coalescing_Operator", "Nullish Coalescing Operator", '', 1)}}</li>
+ <li><a href="https://github.com/tc39/proposals">TC39 proposals</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/pipeline_operator/index.html b/files/pt-br/web/javascript/reference/operators/pipeline_operator/index.html
new file mode 100644
index 0000000000..9de22603c9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/pipeline_operator/index.html
@@ -0,0 +1,65 @@
+---
+title: Operador Pipeline
+slug: Web/JavaScript/Reference/Operators/Pipeline_operator
+translation_of: Web/JavaScript/Reference/Operators/Pipeline_operator
+---
+<div>{{jsSidebar("Operators")}} {{SeeCompatTable}}</div>
+
+<p>O operador experimental pipeline <code>|&gt;</code> (atualmente no estágio 1) permite a criação de chamadas de funções encadeadas de maneira legível. Basicamente, o operador de pipeline fornece açúcar sintático em uma chamada de função com um único argumento, permitindo que você escreva</p>
+
+<p><code>'%21' |&gt; decodeURI</code> ao invés de <code>decodeURI('%21')</code>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">expressão |&gt; função</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Chamadas_de_funções_encadeadas">Chamadas de funções encadeadas</h3>
+
+<p> </p>
+
+<p>O operador de pipeline pode melhorar a legibilidade ao encadear várias funções.</p>
+
+<pre class="brush: js">const double = (n) =&gt; n * 2;
+const increment = (n) =&gt; n + 1;
+
+// sem o perador pipeline
+double(increment(double(double(5)))); // 42
+
+// com o operador pipeline
+5 |&gt; double |&gt; double |&gt; increment |&gt; double; // 42
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><a href="https://tc39.github.io/proposal-pipeline-operator/#sec-intro">Pipeline operator draft</a></td>
+   <td>Estágio 1</td>
+   <td>Não faz parte da especificação ECMAScript ainda.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
+
+<div>
+
+
+<p>{{Compat("javascript.operators.pipeline")}}</p>
+</div>
+
+<h2 id="Ver_também">Ver também</h2>
+
+<ul>
+ <li><a href="https://github.com/tc39/proposals">TC39 proposals</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/property_accessors/index.html b/files/pt-br/web/javascript/reference/operators/property_accessors/index.html
new file mode 100644
index 0000000000..2931effbdb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/property_accessors/index.html
@@ -0,0 +1,189 @@
+---
+title: Assessores de propriedade
+slug: Web/JavaScript/Reference/Operators/Property_Accessors
+translation_of: Web/JavaScript/Reference/Operators/Property_Accessors
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>Os assessores de propriedade fornecem acesso as propriedades de um objeto usando a notação de ponto ou a notação de colchetes.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">object.property
+object["property"]
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><span id="result_box" lang="pt"><span>Pode-se</span> <span>pensar em</span> <span>um objeto</span> <span>como uma matriz associativa</span></span> (a.k.a. <em>map</em>, <em>dictionary</em>, <em>hash</em>, <em>lookup table</em>). As chaves nesta matriz são os nomes das propriedades dos objetos. <span id="result_box" lang="pt"><span>É típico</span> <span>quando se fala de</span> <span>propriedades de um objeto</span> <span>para fazer uma</span> <span>distinção entre</span> <span>propriedades e métodos</span></span>. No entanto, a distinção entre propriedade/método é um pouco mais do que convenção. <span id="result_box" lang="pt"><span>Um método</span> <span>é simplesmente</span> <span>uma propriedade que</span> <span>pode ser chamada</span><span>, por exemplo</span><span>, se tiver</span> <span>uma referência</span> <span>a uma instância</span> <span>de <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Functions">Function</a></span> <span>como seu valor.</span></span></p>
+
+<p>Há duas maneira de acessar propriedades: notação de ponto ou a notação de colchetes.</p>
+
+<h3 id="Notação_de_ponto">Notação de ponto</h3>
+
+<pre class="brush: js">get = object.property;
+object.property = set;
+</pre>
+
+<p>Neste código, a propriedade deve ser um identificador válido, i.e. uma sequência de carácteres alfanuméricos, incluíndo também o underline ("<code>_</code>") e o cifrão ("<code>$</code>"), não pode começar com um número. Por exemplo, <code>object.$1</code> é valido, enquanto <code>object.1</code> não é.</p>
+
+<pre class="brush: js">document.createElement('pre');
+</pre>
+
+<p>Aqui, o método chamado "createElement" <span class="short_text" id="result_box" lang="pt"><span>é recuperado do</span> <span>documento e</span> <span>é chamado.</span></span></p>
+
+<p>Se você usar um método para um literal numérico e o literal numérico não tem expoente e nenhum ponto decimal, deixar de espaço em branco antes do ponto que precede a chamada de método para evitar que o ponto seja interpretado como um ponto decimal.</p>
+
+<pre class="brush: js">77 .toExponential();
+// ou
+77
+.toExponential();
+// ou
+(77).toExponential();
+// ou
+77..toExponential();
+// ou
+77.0.toExponential();
+// porque 77. === 77.0, sem ambiguidade :p</pre>
+
+<h3 id="Notação_de_colchete">Notação de colchete</h3>
+
+<pre class="brush: js">get = object[property_name];
+object[property_name] = set;
+</pre>
+
+<p><code>property_name</code> é uma string. A string não precisa ser um identificador válido; pode ser qualquer valor, e.g. "1foo", "!bar!", ou até " " (um espaço).</p>
+
+<pre class="brush: js">document['createElement']('pre');
+</pre>
+
+<p>Isto faz exatamente a mesma coisa que o exemplo anterior.</p>
+
+<p>Um espaço antes da notação de colchete é permitido.</p>
+
+<pre class="brush: js">document ['createElement']('pre');</pre>
+
+<h3 id="Nomes_de_propriedades"><span class="short_text" id="result_box" lang="pt"><span>Nomes de propriedades</span></span></h3>
+
+<p><span class="short_text" id="result_box" lang="pt"><span>Nomes de propriedades</span></span> devem ser strings. Isto significa que objetos não-string não podem ser usados como chave em um objeto. Qualquer objeto não-string, incluindo um número, é <span class="short_text" id="result_box" lang="pt"><span>estereotipado</span></span> como uma string pelo método <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/toString">toString</a>.</p>
+
+<pre class="brush: js">var object = {};
+object['1'] = 'value';
+console.log(object[1]);
+</pre>
+
+<p>A saída é "value", desde 1 é estereotipado como '1'.</p>
+
+<pre class="brush: js">var foo = {unique_prop: 1}, bar = {unique_prop: 2}, object = {};
+object[foo] = 'value';
+console.log(object[bar]);
+</pre>
+
+<p>A saída também é "value", já que ambos foo e bar são convertidos para a mesma string. No motor de Javascript <a href="/en-US/docs/Mozilla/Projects/SpiderMonkey">SpiderMonkey</a>, esta string poderia ser "['object Object']".</p>
+
+<h3 id="Ligação_de_método">Ligação de método</h3>
+
+<p>Um método não é limitado ao objeto de quem é metodo. Especificamente, <code>this</code> não é fixo em um método, i.e., <code>this</code> não se referece necessariamente ao objeto contendo o método. Ao invés disso, <code>this</code> é "passado" pela função call. Veja <a href="https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Operators/this#Method_binding">method binding</a>.</p>
+
+<h3 id="Nota_sobre_eval">Nota sobre <code>eval</code></h3>
+
+<p>Novatos em JavaScript comentem muitas vezes o erro de usar <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/eval">eval</a> onde a notação de colchete pode ser usada no lugar. Por exemplo, a sintaxe a seguir é muitas vezes vista em muitos scripts.</p>
+
+<pre class="brush: js">x = eval('document.forms.form_name.elements.' + strFormControl + '.value');
+</pre>
+
+<p><code>eval</code> é lento e deve ser evitado sempre que possível. Também, <code>strFormControl</code> would have to hold an identifier, which is not required for names and IDs of form controls. It is better to use bracket notation instead:</p>
+
+<pre class="brush: js">x = document.forms["form_name"].elements[strFormControl].value;
+</pre>
+
+<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>{{SpecName('ESDraft', '#sec-property-accessors', 'Property Accessors')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-property-accessors', 'Property Accessors')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.2.1', 'Property Accessors')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-11.2.1', 'Property Accessors')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Object")}}</li>
+ <li>{{jsxref("Object/defineProperty")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/spread_operator/index.html b/files/pt-br/web/javascript/reference/operators/spread_operator/index.html
new file mode 100644
index 0000000000..4097266877
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/spread_operator/index.html
@@ -0,0 +1,200 @@
+---
+title: Spread operator
+slug: Web/JavaScript/Reference/Operators/Spread_operator
+tags:
+  - JavaScript
+  - Operador
+translation_of: Web/JavaScript/Reference/Operators/Spread_syntax
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>A sintaxe de propagação (<strong>Spread</strong>) permite que um objeto iterável, como um array ou string, seja expandida em locais onde zero ou mais argumentos (para chamadas de função) ou elementos (para literais de array) sejam esperados ou uma expressão de objeto seja expandida em locais onde zero ou mais pares de chave-valor (para literais de objeto) são esperados.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<p>Para chamadas de função:</p>
+
+<pre class="brush: js">minhaFuncao(...objIteravel);
+</pre>
+
+<p>Para array literais:</p>
+
+<pre class="brush: js">[...objIteravel, 4, 5, 6]</pre>
+
+<p>Desestruturação:</p>
+
+<pre class="brush: js">[a, b, ...objIteravel] = [1, 2, 3, 4, 5];</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Uma_melhor_aplicação">Uma melhor aplicação</h3>
+
+<p><strong>Exemplo:</strong> é comum usar {{jsxref( "Function.prototype.apply")}} em casos onde você quer usar um array como argumentos em uma função.</p>
+
+<pre class="brush: js">function minhaFuncao(x, y, z) { }
+var args = [0, 1, 2];
+minhaFuncao.apply(null, args);</pre>
+
+<p>Com o spread do ES2015 você pode agora escrever isso acima como:</p>
+
+<pre class="brush: js">function minhaFuncao(x, y, z) { }
+var args = [0, 1, 2];
+minhaFuncao(...args);</pre>
+
+<p>Qualquer argumento na lista de argumento pode usar a sintaxe spread e pode ser usado várias vezes.</p>
+
+<pre class="brush: js">function minhaFuncao(v, w, x, y, z) { }
+var args = [0, 1];
+minhaFuncao(-1, ...args, 2, ...[3]);</pre>
+
+<h3 id="Um_literal_array_mais_poderoso">Um literal array mais poderoso</h3>
+
+<p><strong>Exemplo:</strong>  Hoje se você tiver um array e quer criar um novo array com esse existente fazendo parte dele, a sintaxe literal do array não é mais suficiente e você deve voltar para o código imperativo, usando uma combinação de <code>push</code>, <code>splice</code>, <code>concat</code>, etc. Com a sintaxe spread isso se torna muito mais sucinto:</p>
+
+<pre class="brush: js">var partes = ['ombros', 'joelhos'];
+var letra = ['cabeca', ...partes, 'e', 'dedos']; // <span class="objectBox objectBox-array"><a class="objectLink "><span class="arrayLeftBracket">[</span></a><span class="objectBox objectBox-string">"</span></span>cabeca<span class="objectBox objectBox-array"><span class="objectBox objectBox-string">"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"</span></span>ombros<span class="objectBox objectBox-array"><span class="objectBox objectBox-string">"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"</span></span>joelhos<span class="objectBox objectBox-array"><span class="objectBox objectBox-string">"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"e"</span><span class="arrayComma">, </span><span class="objectBox objectBox-string">"dedos"</span></span>]
+</pre>
+
+<p>Assim como em spread para listas de argumentos <code>...</code> pode ser usado em qualquer lugar no literal do array e pode ser usado várias vezes.</p>
+
+<h3 id="Apply_para_new">Apply para new</h3>
+
+<p><strong>Exemplo:</strong> No ES5 não é possível usar <code>new</code> com <code>apply.</code> (Em ES5 termos, <code>apply</code> faz uma <code>[[Call]]</code> e nao um <code>[[Construct]].</code>) Em ES2015 a sintaxe spread naturalmente suporta isso:</p>
+
+<pre class="brush: js">var camposData = lerCamposData(bancoDeDados);
+var d = new Date(...camposData);</pre>
+
+<h3 id="Um_push_melhor">Um push melhor</h3>
+
+<p><strong>Exemplo:</strong> {{jsxref("Global_Objects/Array/push", "push")}} é frequentemente usado para adicionar um array no final de um array existente. No ES5 isso é geralmente feito assim:</p>
+
+<pre class="brush: js">var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+// Acrescenta todos itens do arr2 ao arr1
+Array.prototype.push.apply(arr1, arr2);</pre>
+
+<p>No ES2015 com spread isso se torna:</p>
+
+<pre class="brush: js">var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+arr1.push(...arr2);</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array-initializer')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definido em várias seções da especificação: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer">Inicializador do array</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-argument-lists">Listas de argumento</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array-initializer')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_browser">Compatibilidade com browser</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Operação spread em array literais</td>
+   <td>{{CompatChrome("46")}}</td>
+   <td>{{ CompatGeckoDesktop("16") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>Operação spread em chamadas de função</td>
+   <td>{{CompatChrome("46")}}</td>
+   <td>{{ CompatGeckoDesktop("27") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>7.1</td>
+  </tr>
+  <tr>
+   <td>Operação spread em desestruturação</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatGeckoDesktop("34") }}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Operação spread em array literais</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("46")}}</td>
+   <td>{{ CompatGeckoMobile("16") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+   <td>{{CompatChrome("46")}}</td>
+  </tr>
+  <tr>
+   <td>Operação spread em chamadas de função</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatChrome("46")}}</td>
+   <td>{{ CompatGeckoMobile("27") }}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>8</td>
+   <td>{{CompatChrome("46")}}</td>
+  </tr>
+  <tr>
+   <td>Operação spread em desestruturação</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{ CompatGeckoDesktop("34") }}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">Parâmetros rest</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/spread_syntax/index.html b/files/pt-br/web/javascript/reference/operators/spread_syntax/index.html
new file mode 100644
index 0000000000..4eba9de8f7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/spread_syntax/index.html
@@ -0,0 +1,228 @@
+---
+title: Sintaxe de Espalhamento
+slug: Web/JavaScript/Reference/Operators/Spread_syntax
+tags:
+  - ECMAScript 2015
+  - Iterator
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Operators/Spread_syntax
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<div><strong>Sintaxe de Espalhamento (Spread syntax)</strong> permite que um objeto iterável, como uma expressão de array ou uma string seja expandido para ser usado onde zero ou mais argumentos (para chamadas de funções) ou elementos (para arrays <em>literais</em>) são esperados, ou que um objeto seja expandido onde zero ou mais pares <em>propriedade:valor</em> (para objetos <em>literais</em>) são esperados.</div>
+
+<div></div>
+
+<div>{{EmbedInteractiveExample("pages/js/expressions-spreadsyntax.html")}}</div>
+
+<p class="hidden">O código-fonte para este exemplo interativo está armazenado em um repositorio do GitHub. Se você gostaria de contribuir para os exemplos interativos para este projeto, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<p>Para chamada de funções:</p>
+
+<pre class="syntaxbox">myFunction(...iterableObj);
+</pre>
+
+<p>Para arrays literais ou strings:</p>
+
+<pre class="syntaxbox">[...iterableObj, '4', 'five', 6];</pre>
+
+<p>Para objetos literais (novo em ECMAScript 2018; stage 3 draft):</p>
+
+<pre class="syntaxbox">let objClone = { ...obj };</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Espalhamento_e_chamadas_de_funções">Espalhamento e chamadas de funções</h3>
+
+<h4 id="Substituindo_apply">Substituindo apply</h4>
+
+<p>É comum usar {{jsxref( "Function.prototype.apply")}} em casos onde você quer usar os elementos de um array como argumentos para uma função.</p>
+
+<pre class="brush: js">function myFunction(x, y, z) { }
+var args = [0, 1, 2];
+myFunction.apply(null, args);</pre>
+
+<p>Com a sintaxe de espalhamento, o código acima pode ser escrito assim:</p>
+
+<pre class="brush: js">function myFunction(x, y, z) { }
+var args = [0, 1, 2];
+myFunction(...args);</pre>
+
+<p>Qualquer argumento numa lista de argumentos pode usar a sintaxe de espalhamento e pode ser usado mais de uma vez.</p>
+
+<pre class="brush: js">function myFunction(v, w, x, y, z) { }
+var args = [0, 1];
+myFunction(-1, ...args, 2, ...[3]);</pre>
+
+<h4 id="Apply_para_new">Apply para new</h4>
+
+<p>Quando um construtor é chamado com <code>new</code>, não é possivel usar diretamente um array e <code>apply</code> (<code>apply</code> executa o <code>[[Call]]</code> e não o <code>[[Construct]]</code>). No entanto, um array pode facilmente ser usado com <code>new</code> graças ao operador de espalhamento:</p>
+
+<pre class="brush: js">var dateFields = [1970, 0, 1];  // 1 Jan 1970
+var d = new Date(...dateFields);
+</pre>
+
+<p>Para usar o <code>new</code> com array de parâmetros sem a sintaxa de espalhamento, você teria que fazer isso <strong>indiretamente </strong>por meio da aplicação parcial:</p>
+
+<pre class="brush: js">function applyAndNew(constructor, args) {
+   function partial () {
+      return constructor.apply(this, args);
+   };
+   if (typeof constructor.prototype === "object") {
+      partial.prototype = Object.create(constructor.prototype);
+   }
+   return partial;
+}
+
+
+function myConstructor () {
+   console.log("arguments.length: " + arguments.length);
+   console.log(arguments);
+   this.prop1="val1";
+   this.prop2="val2";
+};
+
+var myArguments = ["hi", "how", "are", "you", "mr", null];
+var myConstructorWithArguments = applyAndNew(myConstructor, myArguments);
+
+console.log(new myConstructorWithArguments);
+// (internal log of myConstructor):           arguments.length: 6
+// (internal log of myConstructor):           ["hi", "how", "are", "you", "mr", null]
+// (log of "new myConstructorWithArguments"): {prop1: "val1", prop2: "val2"}</pre>
+
+<h3 id="Espalhamento_em_arrays_literais">Espalhamento em arrays literais</h3>
+
+<h4 id="Um_array_literal_mais_poderoso">Um array literal mais poderoso</h4>
+
+<p>Criar um novo array usando um array existente como parte dele, não é possível utilizando apenas a sintaxe de array literal. O código imperativo deve ser usado ao invés da combinação de <code>push</code>, <code>splice</code>, <code>concat</code>, etc. Com a sintaxe de espalhamento isso se torna muito mais sucinto:</p>
+
+<pre class="brush: js">var parts = ['shoulders', 'knees'];
+var lyrics = ['head', ...parts, 'and', 'toes'];
+// ["head", "shoulders", "knees", "and", "toes"]
+</pre>
+
+<p>Assim como espalhar a lista de argumentos, <code>...</code>  pode ser usado em qualquer lugar em um array literal e pode ser usado multiplas vezes.</p>
+
+<h4 id="Copiando_um_array">Copiando um array</h4>
+
+<pre class="brush: js">var arr = [1, 2, 3];
+var arr2 = [...arr]; // like arr.slice()
+arr2.push(4);
+
+// arr2 becomes [1, 2, 3, 4]
+// arr remains unaffected
+</pre>
+
+<p><strong>Nota:</strong> A sintaxe de espalhamento efetivamente vai um nível mais profundo quando se copia um array. Assim sendo, pode ser inadequado para copiar arrays multidimensionais como o exemplo a seguir mostra (é o mesmo com {{jsxref("Object.assign()")}} e a sintaxe de espalhamento).</p>
+
+<pre class="brush: js">var a = [[1], [2], [3]];
+var b = [...a];
+b.shift().shift(); // 1
+// Now array a is affected as well: [[], [2], [3]]
+</pre>
+
+<h4 id="Uma_maneira_melhor_de_concatenar_arrays">Uma maneira melhor de concatenar arrays</h4>
+
+<p>{{jsxref("Array.concat")}} é frequentemente usado para concatenar um array no final de um array existente. Sem a sintaxe de espalhamento é feito assim:</p>
+
+<pre class="brush: js">var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+// Append all items from arr2 onto arr1
+arr1 = arr1.concat(arr2);</pre>
+
+<p>Com a sintaxe de espalhamento se torna isso:</p>
+
+<pre class="brush: js">var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+arr1 = [...arr1, ...arr2];
+</pre>
+
+<p>{{jsxref("Array.unshift")}} é frequentemente usado para inserir um array de valores no inicio de um array existente. Sem a sintaxe de espalhamento é feito assim:</p>
+
+<pre class="brush: js">var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+// Prepend all items from arr2 onto arr1
+Array.prototype.unshift.apply(arr1, arr2) // arr1 is now [3, 4, 5, 0, 1, 2]</pre>
+
+<p>Com a <em>sintaxe de espalhamento</em> isso se torna <em>[Note, no entanto, que isso cria um novo <code>arr1</code> array. Ao contrário de {{jsxref("Array.unshift")}}, isso não modifica o array original <code>arr1</code> array]</em>:</p>
+
+<pre class="brush: js">var arr1 = [0, 1, 2];
+var arr2 = [3, 4, 5];
+arr1 = [...arr2, ...arr1]; // arr1 is now [3, 4, 5, 0, 1, 2]
+</pre>
+
+<h3 id="Espalhamento_em_objetos_literais">Espalhamento em objetos literais</h3>
+
+<p>A proposta <a href="https://github.com/tc39/proposal-object-rest-spread">Rest/Spread Properties for ECMAScript</a> (stage 3) adiciona espalhamento de propriedades para <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">objetos literais</a>. Este copia as propriedades enumeráveis de um objeto informado em um novo objeto.</p>
+
+<p><strong>Cópia-rasa (Shallow-cloning)</strong> (excluindo o protótipo) ou fusão (<strong>merge</strong>) de objetos agora é possivel usando uma sintaxe mais curta que {{jsxref("Object.assign()")}}.</p>
+
+<pre class="brush: js">var obj1 = { foo: 'bar', x: 42 };
+var obj2 = { foo: 'baz', y: 13 };
+
+var clonedObj = { ...obj1 };
+// Object { foo: "bar", x: 42 }
+
+var mergedObj = { ...obj1, ...obj2 };
+// Object { foo: "baz", x: 42, y: 13 }</pre>
+
+<p>Note que {{jsxref("Object.assign()")}} chamada os <a href="/en-US/docs/Web/JavaScript/Reference/Functions/set">setters</a> e a <em>sintaxe de espalhamento</em> não.</p>
+
+<h3 id="Apenas_para_iteráveis">Apenas para iteráveis</h3>
+
+<p>A sintaxe de espalhamento (diferente de propriedades espalhadas) só pode ser utilizada com objetos iteráveis.</p>
+
+<pre class="brush: js">var obj = {'key1': 'value1'};
+var array = [...obj]; // TypeError: obj is not iterable
+</pre>
+
+<h3 id="Espalhamento_com_muitos_valores">Espalhamento com muitos valores</h3>
+
+<p>Quando usar a sintaxe de espalhamento para chamada de funções, esteja ciente da possibilidade de exceder tamanho máximo de argumentos do motor do Javascript. Veja <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply" title="The apply() method calls a function with a given this value, and arguments provided as an array (or an array-like object)."><code>apply()</code></a> para mais detalhes.</p>
+
+<h2 id="Sintaxe_Rest_parâmetros">Sintaxe Rest (parâmetros)</h2>
+
+<p>A <em>sintaxe rest</em> se parece exatamente como a <em>sintaxe de espalhamento</em>, mas esta é usada para desestruturar arrays e objetos. De certa forma, a <em>sintaxe rest</em> é o oposto da <em>sintaxe de espalhamento</em>: A <em>sintaxe de espalhamento (spread)</em> 'expande' um array em vários elementos, enquanto a <em>sintaxe rest</em> coleta multiplos elementos e 'condensa' eles em um único elemento. Veja <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">parâmetros rest.</a></p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Specification</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comment</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-array-initializer')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Defined in several sections of the specification: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-array-initializer">Array Initializer</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-argument-lists">Argument Lists</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-array-initializer')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>No changes.</td>
+  </tr>
+  <tr>
+   <td><a href="https://github.com/tc39/proposal-object-rest-spread">Rest/Spread Properties for ECMAScript </a></td>
+   <td>Draft</td>
+   <td>Stage 3 draft.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_Navegadores">Compatibilidade com Navegadores</h2>
+
+<div class="hidden">A tabela de compatibilidade nessa página é gerada a partir de dados estruturados. Se você gostaria de contribuir com dados, por favor verifique <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos mande um pull request.</div>
+
+<p>{{Compat("javascript.operators.spread")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/rest_parameters">Parâmetros Rest</a> (also ‘<code>...</code>’)</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/super/index.html b/files/pt-br/web/javascript/reference/operators/super/index.html
new file mode 100644
index 0000000000..616f708dc9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/super/index.html
@@ -0,0 +1,226 @@
+---
+title: super
+slug: Web/JavaScript/Reference/Operators/super
+translation_of: Web/JavaScript/Reference/Operators/super
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>A palavra-chave <strong>super</strong> é usada para acessar o objeto pai de um objeto, em outros casos, é usada para acessar a classe pai de uma classe.</p>
+
+<h2 id="Síntaxe">Síntaxe</h2>
+
+<pre class="syntaxbox">// chama o objeto (ou construtor) pai
+super(...[arguments]);
+// chama um método da classe/objeto pai
+super.metodo([arguments]);
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Quando usada no construtor de uma classe, a palavra-chave <code>super</code> deve ser usada apenas uma vez, e precisa ser usada antes que a palavra-chave <code>this</code> possa ser usada. Essa palavra-chave também pode ser usada para chamar uma função ou objeto pai.</p>
+
+<h2 id="Exemplo">Exemplo</h2>
+
+<h3 id="Usando_super_em_classes">Usando <code>super</code> em classes</h3>
+
+<p>Esse trecho de código foi obtido através de <a href="https://github.com/GoogleChrome/samples/blob/gh-pages/classes-es6/index.html">classes sample</a> (<a href="https://googlechrome.github.io/samples/classes-es6/index.html">demonstração</a>). Aqui <code>super()</code> é chamado para evitar duplicar a parte do construtor que é comum entre <code>Polygon</code> e <code>Square</code>.</p>
+
+<pre class="brush: js">class Polygon {
+  constructor(height, width) {
+    this.name = 'Polygon';
+    this.height = height;
+    this.width = width;
+  }
+  sayName() {
+    console.log('Hi, I am a ', this.name + '.');
+  }
+}
+
+class Square extends Polygon {
+  constructor(length) {
+    this.height; // ReferenceError, precisa chamar o super primeiro!
+
+    // Aqui, ele chama a classe construtora pai com o tamanho
+    // provido pelo Polygon -&gt; width e height
+    super(length, length);
+
+    // Nota: Em classes derivadas, <code>super()</code> deve ser chamado antes de
+    // usar <code>this</code>. Deixar isso de fora vai causar um ReferenceError.
+    this.name = 'Square';
+  }
+
+  get area() {
+    return this.height * this.width;
+  }
+
+  set area(value) {
+    this.area = value;
+  }
+}</pre>
+
+<h3 id="Super_chamando_métodos_estáticos">Super chamando métodos estáticos</h3>
+
+<p>Você também pode chamar o super em métodos <a href="/en-US/docs/Web/JavaScript/Reference/Classes/static">estáticos</a>.</p>
+
+<pre class="brush: js">class Human {
+  constructor() {}
+  static ping() {
+    return 'ping';
+  }
+}
+
+class Computer extends Human {
+  constructor() {}
+  static pingpong() {
+    return super.ping() + ' pong';
+  }
+}
+Computer.pingpong(); // 'ping pong'
+</pre>
+
+<h3 id="Ao_deletar_propriedades_do_super_será_emitido_um_erro">Ao deletar propriedades do super, será emitido um erro</h3>
+
+<p>Você não pode utilizar o <a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete operator</a> e <code>super.prop</code> ou <code>super[expr]</code> para deletar uma propriedade da classe pai. Isto emitirá um {{jsxref("ReferenceError")}}.</p>
+
+<pre class="brush: js">class Base {
+  constructor() {}
+  foo() {}
+}
+class Derived extends Base {
+  constructor() {}
+  delete() {
+    delete super.foo;
+  }
+}
+
+new Derived().delete(); // ReferenceError: invalid delete involving 'super'. </pre>
+
+<h3 id="Super.prop_não_pode_sobrescrever_propriedades_não_editáveis"><code>Super.prop</code> não pode sobrescrever propriedades não editáveis</h3>
+
+<p><code>super</code>Whennão pode sobrescrever o valor de uma propriedade quando esta houver sido definida como não editável ('writable: false') com, e.g., {{jsxref("Object.defineProperty")}}.</p>
+
+<pre class="brush: js">class X {
+  constructor() {
+    Object.defineProperty(this, "prop", {
+      configurable: true,
+      writable: false,
+      value: 1
+    });
+  }
+  f() {
+    super.prop = 2;
+  }
+}
+
+var x = new X();
+x.f();
+console.log(x.prop); // 1
+</pre>
+
+<h3 id="Usando_super.prop_em_objetos_literais">Usando <code>super.prop</code> em objetos literais</h3>
+
+<p><code>super</code> também pode ser usado na inicialização da notação literal de objetos. No exemplo abaixo, cada objeto define um método. No segundo objeto, <code>super</code> chama o método do primeiro objeto. Isso funciona graças ao {{jsxref("Object.setPrototypeOf()")}}, com o qual é possível configurar o prototype do <code>obj2</code> para o <code>obj1</code>, tornando o <code>super</code> capaz de encontrar o <code>method1()</code> por meio do <code>obj2</code>.</p>
+
+<pre class="brush: js">var obj1 = {
+  method1() {
+    console.log("method 1");
+  }
+}
+
+var obj2 = {
+  method2() {
+   super.method1();
+  }
+}
+
+Object.setPrototypeOf(obj2, obj1);
+obj2.method2(); // retorna "method 1"
+</pre>
+
+<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>{{SpecName('ES6', '#sec-super-keyword', 'super')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-super-keyword', 'super')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatGeckoDesktop(45)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Android Webview</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+   <th>Chrome for Android</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatChrome(42.0)}}</td>
+   <td>{{CompatGeckoMobile(45)}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatChrome(42.0)}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_Gecko_específicas">Notas Gecko específicas</h2>
+
+<ul>
+ <li><code>super()</code> ainda não funciona como esperado para prototypes nativos.</li>
+</ul>
+
+<h2 id="Veja_mais">Veja mais</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/this/index.html b/files/pt-br/web/javascript/reference/operators/this/index.html
new file mode 100644
index 0000000000..dc1798e093
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/this/index.html
@@ -0,0 +1,410 @@
+---
+title: this
+slug: Web/JavaScript/Reference/Operators/this
+tags:
+  - Expressões Primárias
+  - JavaScript
+  - Operador
+  - Referencia
+translation_of: Web/JavaScript/Reference/Operators/this
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>A palavra-chave <strong><code>this</code></strong> comporta-se um pouco diferente em Javascript se comparado com outras linguagens. Também possui algumas diferenças entre o <a href="https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Funciones/Modo_estricto" title="en-US/docs/JavaScript/Strict mode">modo estrito</a> e o modo não estrito.</p>
+
+<p>Em muitos casos, o valor <code>this</code> é determinado pela forma como a função é chamada. Ele não pode ser assinado durante a execução, e isso pode ser diferente a cada vez que a função é chamada. ES5 introduziu o método <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">bind</a></code> para estabelecer o valor <code>this</code> da função, independentemente de como ela seja chamada, e ECMAScript 2015 introduziu o <a href="../Functions/Arrow_functions">arrow functions</a>, cujo <code>this</code> é lexicalmente delimitado (o valor <code>this</code> é estabelecido segundo o escopo de execução no qual está inserido).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">this</pre>
+
+<h2 id="Contexto_global">Contexto global</h2>
+
+<p>No contexto de execução global (fora de qualquer função), <code>this</code> refere-se ao objeto global, seja em modo estrito ou não.</p>
+
+<pre class="brush:js">console.log(this.document === document); // true
+
+// Em navegadores web, o objeto window é também o objeto global:
+console.log(this === window); // true
+
+this.a = 37;
+console.log(window.a); // 37
+</pre>
+
+<h2 id="Contexto_de_função">Contexto de função</h2>
+
+<p>Dentro de uma função, o valor de <code>this</code> depende de como a função é chamada.</p>
+
+<h3 id="Chamada_simples">Chamada simples</h3>
+
+<p>Como o código a seguir não está no modo estrito, o valor de <code>this</code> não é definido pela chamada. Por padrão, <code>this</code> será o objeto global que no navegador é o <code>window</code>.</p>
+
+<pre class="brush: js">function f1(){
+  return this;
+}
+
+// No navegador
+f1() === window; // true
+</pre>
+
+<p>Em modo estrito, o valor de <code>this</code> permanece seja qual for o definido ao entrar no contexto de execução, assim, no caso a seguir, <code>this</code> por padrão será indefinido (<code>undefined</code>):</p>
+
+<pre class="brush:js">function f2(){
+  "use strict"; // assume modo estrito
+  return this;
+}
+
+f2() === undefined; // true
+</pre>
+
+<p>Portanto, em modo estrito, se <code>this</code> não for definido durante o contexto da execução, ele permanecerá indefinido (<code>undefined</code>).</p>
+
+<div class="note">No segundo exemplo, <code>this</code> deveria ser <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined"><code>undefined</code></a>, porque <code>f2</code> foi chamada diretamente e não como um método ou popriedade de um objeto (ou seja, <code>window.f2()</code>). Esta característica não foi implementada em alguns navegadores quando começaram a dar suporte ao <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode" title="Strict mode">strict mode</a> (modo estrito). Como resultado, eles incorretamente retornavam o objeto <code>window</code>.</div>
+
+<p> </p>
+
+<h3 id="Funções_Arrow_(seta)">Funções Arrow (seta)</h3>
+
+<p>Nas <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow functions</a> (funções seta), o <code>this</code> é definido lexicalmente, isto é, seu valor é definido pelo contexto de execução onde está inserido. Em um código global, this assume o objeto global:</p>
+
+<pre class="brush: js">var globalObject = this;
+var foo = (() =&gt; this);
+console.log(foo() === globalObject); // true</pre>
+
+<p>Não importa como <code>foo</code> é chamado, o <code>this</code> continuará como o objeto global. Isto continua verdadeiro mesmo se chamá-lo como método de um determinado objeto (o que normalmente definiria seu this ao objeto), com <code>call</code> ou <code>apply</code> ou <code>bind</code> é usado:</p>
+
+<pre class="brush: js">// Chama como um método de um objeto
+var obj = {foo: foo};
+console.log(obj.foo() === globalObject); // true
+
+// Tentativa de definir this usando call
+console.log(foo.call(obj) === globalObject); // true
+
+// Tentantiva de definir this usando bind
+foo = foo.bind(obj);
+console.log(foo() === globalObject); // true</pre>
+
+<p>Não importa como for, o this do foo mantém o valor que recebeu quando foi criado (no exemplo acima, o objeto global). O mesmo se aplica para funções arrow criadas dentro de outras funções: seus this são definidos em seus respectivos contextos de execução.</p>
+
+<pre class="brush: js">// Cria obj com um método bar que retorna uma função que
+// retorna seu this. A função retornada é criada como
+// uma função arrow, para que seu this esteja permanentemente
+// ligado ao this da função que a envolve. O valor de bar pode ser // definido na chamada, que por sua vez define o valor da função
+// retornada.
+var obj = { bar : function() {
+                    var x = (() =&gt; this);
+                    return x;
+                  }
+          };
+
+// Chama bar como método de obj, configurando seu this como obj
+// Assina à variável fn uma referência para a função retornada
+var fn = obj.bar();
+
+// Chamar fn, sem definir this, por padrão, referenciaria
+// ao objeto global ou undefined em modo estrito (strict mode)
+console.log(fn() === obj); // true</pre>
+
+<p>No exemplo acima, a função (chamemos função anônima A) atribuída a obj.bar retorna outra função (chamemos função anônima B) que é criada como uma função arrow (seta). Como resultado, o this da função B é permanentemente definido como o this de obj.bar (função A) quando chamado. Quando a função retornada (função B) é chamada, seu this sempre será aquele que foi definido inicialmente. No exemplo de código acima, o this da função B é definido com o this da função A, que é obj, por isso permanece definido para obj, mesmo quando chamado de uma maneira que normalmente definiria seu this como undefined ou como objeto global (ou qualquer outro método, como naquele exemplo anterior de contexto de execução global).</p>
+
+<h3 id="Como_método_de_um_objeto">Como método de um objeto</h3>
+
+<p>Quando uma função é chamada como um método de um objeto, seu this toma o valor do objeto pertencente ao método chamado.</p>
+
+<p>No exemplo a seguir, quando <code>o.f()</code> é invocado, o this dentro da função é vinculado ao objeto o.</p>
+
+<pre class="brush:js">var o = {
+  prop: 37,
+  f: function() {
+    return this.prop;
+  }
+};
+
+console.log(o.f()); // logs 37
+</pre>
+
+<p>Observe que esse comportamento não é afetado mesmo pela forma como (ou onde) a função foi definida. No exemplo anterior, nós definimos a função in-line (em linha) como o membro f durante a definição de o. No entanto, poderíamos ter apenas facilmente definido a função primeiro e depois anexado a o.f. Fazendo isso resulta no mesmo comportamento:</p>
+
+<pre class="brush:js">var o = {prop: 37};
+
+function independent() {
+  return this.prop;
+}
+
+o.f = independent;
+
+console.log(o.f()); // registra 37
+</pre>
+
+<p>Isto demonstra que é importante apenas que a função foi chamada a partir do membro f de o.</p>
+
+<p>Da mesma forma, a vinculação de this só é afetada pela referência do membro mais imediato. No exemplo a seguir, quando invocamos a função, podemos chamá-la como um método g do objeto o.b. Desta vez, durante a execução, o this dentro da função irá se referir a o.b. O fato do objeto ser um membro de o não tem qualquer consequência; a referência mais imediata é tudo que importa.</p>
+
+<pre class="brush:js">o.b = {g: independent, prop: 42};
+console.log(o.b.g()); // registra 42
+</pre>
+
+<h4 id="this_na_cadeia_de_protótipos_(prototype_chain)_do_objeto"><code>this</code> na cadeia de protótipos (prototype chain) do objeto</h4>
+
+<p>A mesma noção vale para métodos definidos em algum lugar da cadeia de protótipos do objeto. Se o método está na cadeia de protótipo de um objeto, this refere-se ao objeto que é proprietário do método chamado, como se o método estivesse no objeto.</p>
+
+<pre class="brush:js">var o = {f:function(){ return this.a + this.b; }};
+var p = Object.create(o);
+p.a = 1;
+p.b = 4;
+
+console.log(p.f()); // 5
+</pre>
+
+<p>Neste exemplo, o objeto atribuído à variável p não tem sua própria propriedade f, ele o herda de seu protótipo. Mas não importa que a procura por f finalmente encontre um membro com esse nome em o; a procura começou como uma referência para a p.f, portanto o this dentro da função recebe o valor do objeto referido como p. Isto é, já que f é chamado como um método de p, seu this refere-se a p. Este é um recurso interessante de herança prototípica do JavaScript.</p>
+
+<h4 id="this_com_seletores_(getter)_ou_modificadores_(setter)"><code>this</code> com seletores (getter) ou modificadores (setter) </h4>
+
+<p>Mais uma vez, a mesma noção se aplica quando uma função é chamada a partir de um getter ou setter. A função usada como getter ou setter tem seu this ligado ao objeto do qual a propriedade está sendo modificada ou selecionada.</p>
+
+<pre class="brush:js">function modulus(){
+  return Math.sqrt(this.re * this.re + this.im * this.im);
+}
+
+var o = {
+  re: 1,
+  im: -1,
+  get phase(){
+    return Math.atan2(this.im, this.re);
+  }
+};
+
+Object.defineProperty(o, 'modulus', {
+    get: modulus, enumerable:true, configurable:true});
+
+console.log(o.phase, o.modulus); // logs -0.78 1.4142
+</pre>
+
+<h3 id="Como_um_construtor_(constructor)">Como um construtor (constructor)</h3>
+
+<p>Quando a função é usada com um construtor (com a palavra chave <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/new">new</a></code>), seu this é vinculado ao novo objeto sendo contruído.</p>
+
+<p>Nota: enquanto o padrão para um construtor é retornar o objeto referenciado por this, ele pode retornar, ao invés, algum outro objeto (se o valor de retorno não é um objeto, então o objeto this é retornado).</p>
+
+<pre class="brush:js">/*
+ * Contrutores funcionam da seguinte forma:
+ *
+ * function MyConstructor(){
+ *   // O código do corpo da função vai aqui.
+ *   // Criam-se propriedades sobre |this| como
+ *   // desejado, assinando-os. Ex.,
+ *   this.fum = "nom";
+ *   // etc...
+ *
+ *   // Se a função tem uma instrução que
+ *   // retorna um objeto, esse objeto será o
+ *   // resultado da expressão |new|. Caso contrário,
+ *   // o resultado da expressão é o objeto
+ *   // atualmente vinculado a |this|
+ *   // (i.e., o caso mais comumente visto).
+ * }
+ */
+
+function C(){
+  this.a = 37;
+}
+
+var o = new C();
+console.log(o.a); // logs 37
+
+
+function C2(){
+  this.a = 37;
+  return {a:38};
+}
+
+o = new C2();
+console.log(o.a); // registra 38
+</pre>
+
+<p>No último exemplo (C2), porque um objeto foi retornado durante a construção, o novo objeto que this foi vinculado simplesmente é descartado. (Isso essencialmente faz da expressão "this.a = 37;" código morto. Não é exatamente morto, pois ele é executado, mas ele pode ser eliminado sem efeitos colaterais.)</p>
+
+<h3 id="call_e_apply"><code>call</code> e <code>apply</code></h3>
+
+<p>Quando uma função usa a palavra-chave this em seu corpo, o seu valor pode ser vinculado a um determinado objeto na chamada utilizando os métodos <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/call">call</a></code> or <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/apply">apply</a></code> que todas as funções herdam de Function.prototype.</p>
+
+<pre class="brush:js">function add(c, d){
+  return this.a + this.b + c + d;
+}
+
+var o = {a:1, b:3};
+
+// O primeiro parâmetro é o objeto a usar como
+// 'this'; subsequentes parâmetros são passados como
+// argumentos na função chamada
+add.call(o, 5, 7); // 1 + 3 + 5 + 7 = 16
+
+// O primeiro parâmetro é o objeto a usar como
+// 'this', o segundo é um arranjo (array) cujos
+// membros são usados como argumentos na função chamada
+add.apply(o, [10, 20]); // 1 + 3 + 10 + 20 = 34
+</pre>
+
+<p>Observe que, com call e apply, se o valor passado como this não for um objeto, será feita uma tentativa de convertê-lo em um objeto usando a operação interna ToObject. Portanto, se o valor passado é um primitivo como 7 ou 'foo', ele será convertido para um objeto usando o construtor relacionado, de modo que o número primitivo 7 é convertido em um objeto, como realizado por new Number(7), e a cadeia de caracteres 'foo' em um objeto, como realizado por new String(' foo '), por exemplo.</p>
+
+<pre class="brush:js">function bar() {
+  console.log(Object.prototype.toString.call(this));
+}
+
+bar.call(7); // [object Number]
+</pre>
+
+<h3 id="O_método_bind">O método <code>bind</code></h3>
+
+<p>ECMAScript 5 introduziu <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/bind">Function.prototype.bind</a></code>. Chamando f.bind(algumObjeto) cria-se uma nova função com o mesmo corpo e escopo que f, mas onde o this ocorrer na função original, na nova função ele será permanentemente ligado ao primeiro argumento de bind, independentemente de como a função esteja sendo usada.</p>
+
+<pre class="brush:js">function f(){
+  return this.a;
+}
+
+var g = f.bind({a:"azerty"});
+console.log(g()); // azerty
+
+var h = g.bind({a: 'yoo'}); // bind só funciona uma vez!
+console.log.(h()); // azerty
+
+var o = {a:37, f:f, g:g, h: h};
+console.log(o.a, o.f(), o.g(), o.h()); // 37, 37, azerty, azerty
+</pre>
+
+<h3 id="Como_um_manipulador_de_eventos_DOM">Como um manipulador de eventos DOM</h3>
+
+<p>Quando uma função é usada como um manipulador de eventos, seu this está definido para o elemento do evento a partir do qual foi disparado (alguns navegadores não seguem essa convenção para os listeners adicionados dinamicamente com métodos que não sejam addEventListener).</p>
+
+<pre class="brush:js">// Quando chamado como listener, transforma o elemento blue
+// relacionado
+function bluify(e){
+  // sempre true
+  console.log(this === e.currentTarget);
+  // true quando currentTarget e target são o mesmo objeto
+  console.log(this === e.target);
+  this.style.backgroundColor = '#A5D9F3';
+}
+
+// Obtém uma lista de todo elemento no documento
+var elements = document.getElementsByTagName('*');
+
+// Adiciona bluify com um click listener (escutador de click)
+// para que quando o elemento seja clicado se torne azul
+for(var i=0 ; i&lt;elements.length ; i++){
+  elements[i].addEventListener('click', bluify, false);
+}</pre>
+
+<h3 id="Em_um_manipulador_de_evento_in-line_(em_linha)">Em um manipulador de evento in-line (em linha)</h3>
+
+<p>Quando o código é chamado de um manipulador de evento in-line, seu this está definido para o elemento DOM em que o listener é colocado:</p>
+
+<pre class="brush:js">&lt;button onclick="alert(this.tagName.toLowerCase());"&gt;
+  Show this
+&lt;/button&gt;
+</pre>
+
+<p>O alerta acima mostra button. Note, porém, que apenas o código exterior tem um this definido desta maneira:</p>
+
+<pre class="brush:js">&lt;button onclick="alert((function(){return this}()));"&gt;
+  Show inner this
+&lt;/button&gt;
+</pre>
+
+<p>Neste caso, o this da função interior não está definido, portanto ele retorna o objeto global/objeto window (ou seja, o objeto padrão no modo não-estrito onde this não está definido pela chamada).</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-this-keyword', 'The this keyword')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-this-keyword', 'The this keyword')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.1.1', 'The this keyword')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-11.1.1', 'The this keyword')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-11.1.1', 'The this keyword')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Initial definition. Implemented in JavaScript 1.0.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">Strict mode</a></li>
+ <li><a href="http://bjorn.tipling.com/all-this">All this</a>, um artigo sobre this em diferentes contextos</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/typeof/index.html b/files/pt-br/web/javascript/reference/operators/typeof/index.html
new file mode 100644
index 0000000000..aa6204c2fb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/typeof/index.html
@@ -0,0 +1,154 @@
+---
+title: typeof
+slug: Web/JavaScript/Reference/Operators/typeof
+tags:
+  - JavaScript
+  - Operador
+  - unário
+translation_of: Web/JavaScript/Reference/Operators/typeof
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<h2 id="Sumário">Sumário</h2>
+
+<p>O operador <code>typeof</code> retorna uma string indicando o tipo de um operando.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<p>O operador <code>typeof</code> pode ser utilizado das seguintes maneiras:</p>
+
+<pre class="syntaxbox"><code>typeof <code><em>operando</em></code></code></pre>
+
+<h3 id="Parâmetros">Parâmetros</h3>
+
+<p><code><em>operand</em></code>o é a string, variável, keyword, ou objeto para que o tipo do mesmo seja retornado. O uso de parênteses é opcional.</p>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Esta tabela resume os possíveis valores que são retornados pelo <code>typeof</code>:</p>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Tipo</th>
+   <th scope="col">Resultado</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>Undefined</td>
+   <td><code>"undefined"</code></td>
+  </tr>
+  <tr>
+   <td>Null</td>
+   <td><code>"object"</code></td>
+  </tr>
+  <tr>
+   <td>Boolean</td>
+   <td><code>"boolean"</code></td>
+  </tr>
+  <tr>
+   <td>Number</td>
+   <td><code>"number"</code></td>
+  </tr>
+  <tr>
+   <td>String</td>
+   <td><code>"string"</code></td>
+  </tr>
+  <tr>
+   <td>Host object (provided by the JS environment)</td>
+   <td><em>Implementation-dependent</em></td>
+  </tr>
+  <tr>
+   <td>Function object (implements [[Call]] in ECMA-262 terms)</td>
+   <td><code>"function"</code></td>
+  </tr>
+  <tr>
+   <td>E4X XML object</td>
+   <td>"xml"</td>
+  </tr>
+  <tr>
+   <td>E4X XMLList object</td>
+   <td>"xml"</td>
+  </tr>
+  <tr>
+   <td>Qualquer outro objeto</td>
+   <td><code>"object"</code></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Casos_comuns">Casos comuns</h3>
+
+<pre class="brush:js">// Números - Numéricos
+typeof 37 === 'number';
+typeof 3.14 === 'number';
+typeof Math.LN2 === 'number';
+typeof Infinity === 'number';
+typeof NaN === 'number'; // Apesar de ser "Não-Numérico"
+typeof Number(1) === 'number'; // mas nunca utilize desta forma!
+
+// Strings - Seqüências de caracteres
+typeof "" === 'string';
+typeof "bla" === 'string';
+typeof (typeof 1) === 'string'; // typeof sempre retorna uma string
+typeof String("abc") === 'string'; // mas nunca utilize desta forma!
+
+// Booleans - Lógicos booleanos
+typeof true === 'boolean';
+typeof false === 'boolean';
+typeof Boolean(true) === 'boolean'; // mas nunca utilize desta forma!
+
+// Undefined - Indefinidos
+typeof undefined === 'undefined';
+typeof blabla === 'undefined'; // uma variável indefinida
+
+// Objetos
+typeof {a:1} === 'object';
+typeof [1, 2, 4] === 'object'; // use Array.isArray ou Object.prototype.toString.call para diferenciar os objetos das arrays
+typeof new Date() === 'object';
+
+typeof new Boolean(true) === 'object'; // isto é confuso, portanto não use desta forma!
+typeof new Number(1) === 'object'; // isto é confuso, portanto não use desta forma!
+typeof new String("abc") === 'object';  // isso também é confuso, assim evite usar esta construção!
+
+// Funções
+typeof function(){} === 'function';
+typeof Math.sin === 'function';
+</pre>
+
+<h3 id="null"><code>null</code></h3>
+
+<pre class="brush:js">// Desde os primóridos do JavaScript
+typeof null === 'object';
+</pre>
+
+<p>Na primeira implementação do JavaScript, valores em JavaScript foram representados com uma tag (etiqueta) de tipo e um valor. A tag de tipo para objetos foi 0. <code>null</code> foi representada com o ponteiro NULL (0x00 na maioria das plataformas). Consequentemente, null teve 0 como sua tag de tipo, portanto o <code>typeof</code> retorna esse valor. (necessário referência)</p>
+
+<p>Está previsto <a class="external" href="http://wiki.ecmascript.org/doku.php?id=harmony:typeof_null">para ser corrigido na próxima versão do ECMAScript</a> (que estará disponível através de um opt-in). Isso resultará em um <code>typeof null === 'null'</code>.</p>
+
+<h3 id="Expressões_regulares">Expressões regulares</h3>
+
+<p>Expressões regulares que podem ser chamadas foram uma adição não-padrão em alguns browsers (<span id="result_box" lang="pt"><span class="hps">necessidade</span> <span class="hps">de referência</span> <span class="hps">para dizer</span> <span class="hps">qual</span></span>).</p>
+
+<pre class="brush:js">typeof /s/ === 'function'; // Chrome 1-12 ... // Não-conforme no ECMAScript 5.1
+typeof /s/ === 'object'; // Firefox 5+ ...    // Conforme no ECMAScript 5.1
+</pre>
+
+<h3 id="Outras_peculiaridades">Outras peculiaridades</h3>
+
+<h4 id="alert_versões_antigas_do_Internet_Explorer"><code>alert</code> versões antigas do Internet Explorer</h4>
+
+<p>No IE 6, 7 e 8, <code>typeof alert === 'object'</code></p>
+
+<h2 id="Especificação">Especificação</h2>
+
+<p><a class="external" href="http://ecma-international.org/ecma-262/5.1/#sec-11.4.3">ECMA-262 section 11.4.3</a></p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/JavaScript/Reference/Operators/instanceof" title="/en-US/docs/JavaScript/Reference/Operators/instanceof">instanceof</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/void/index.html b/files/pt-br/web/javascript/reference/operators/void/index.html
new file mode 100644
index 0000000000..f3d4bf5c45
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/void/index.html
@@ -0,0 +1,141 @@
+---
+title: void operator
+slug: Web/JavaScript/Reference/Operators/void
+tags:
+  - JavaScript
+  - Operador
+  - Operadores
+  - unário
+translation_of: Web/JavaScript/Reference/Operators/void
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>O <strong><code>operador void</code></strong> avalia a expressão dada e, em seguida, retorna {{jsxref("Global_Objects/undefined", "undefined")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox" id="void_expressão">void <em>expressão</em></pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Este operador permite a inserção de expressões que produzem efeitos secundários em lugares onde uma expressão que avalia a ação {{jsxref("Global_Objects/undefined", "undefined")}} é desejada.</p>
+
+<p>O operador <code>void</code> é muitas vezes utilizado apenas para obter o valor primitivo <code>undefined</code>, geralmente usando "<code>void(0)</code>" (o que equivale a "<code>void 0</code>"). Nestes casos, a variável global {{jsxref("Global_Objects/undefined", "undefined")}} pode ser utilizado em vez (supondo que ele não tenha sido atribuído a um valor não-padrão).</p>
+
+<h2 id="Chamada_imediata_das_expressões_da_função">Chamada imediata das expressões da função</h2>
+
+<p>Quando usamos uma <a href="/en-US/docs/Glossary/IIFE">Chamada imediata das expressões da função</a>, valores nulos podem ser usado para forçar a palavra-chave da função a ser tratada como uma expressão em vez de uma declaração.</p>
+
+<pre class="brush: js">void function iife() {
+    var bar = function () {};
+    var baz = function () {};
+    var foo = function () {
+        bar();
+        baz();
+     };
+    var biz = function () {};
+
+    foo();
+    biz();
+}();
+</pre>
+
+<h2 id="JavaScript_URIs">JavaScript URIs</h2>
+
+<p>Quando o navegador segue uma URI <code>javascript</code>, ele avalia o código na URI e então troca o conteúdo da página pelo valor retornado por este, a não ser que o valor retornado seja {{jsxref("Global_Objects/undefined", "undefined")}}. O operador <code>void</code> pode ser usado para retornar {{jsxref("Global_Objects/undefined", "undefined")}}. Por exemplo:</p>
+
+<pre class="brush: html">&lt;a href="javascript:void(0);"&gt;
+  Clique aqui para não fazer nada
+&lt;/a&gt;
+
+&lt;a href="javascript:void(document.body.style.backgroundColor='green');"&gt;
+  Clique aqui para o papel de parede ser verde
+&lt;/a&gt;
+</pre>
+
+<p>Note que no entanto o pseudo protocolo <code>javascript:</code> tem seu uso desencorajado perante outras alternativas como <em>unobtrusive event handlers</em>.</p>
+
+<h2 id="Specificações">Specificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>ECMAScript 1</td>
+   <td>Standard</td>
+   <td>Initial definition. Implemented in JavaScript 1.1</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-11.4.2', 'The void Operator')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-void-operator', 'The void Operator')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores"><span class="short_text" id="result_box" lang="pt"><span class="hps">Compatibilidade dos navegadores</span></span></h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/yield/index.html b/files/pt-br/web/javascript/reference/operators/yield/index.html
new file mode 100644
index 0000000000..f3fcb80345
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/yield/index.html
@@ -0,0 +1,181 @@
+---
+title: yield
+slug: Web/JavaScript/Reference/Operators/yield
+tags:
+  - ECMAScript 2015
+  - Generators
+  - Iterator
+  - JavaScript
+  - Operador
+  - Operator
+translation_of: Web/JavaScript/Reference/Operators/yield
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>A palavra-chave <code>yield</code> é usada para pausar e resumir uma generator function ({{jsxref("Statements/function*", "function*")}} or <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Legacy_generator_function">generator function legada</a>).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">[<em>rv</em>] = <strong>yield</strong> [<em>expressão</em>];</pre>
+
+<dl>
+ <dt><code>expressão</code></dt>
+ <dd>Define o valor que retorna de uma generator function via <a href="/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#The_iterator_protocol">o protocolo iterator</a>. Se omitido, será retornado <code>undefined</code>.</dd>
+ <dt><code>rv</code></dt>
+ <dd>
+ <p>Retorna o valor opcional passado para o metódo <code>next()</code> do generator e resume sua execução.</p>
+ </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A palavra-chave <code>yield</code> pausa a execução de uma generator function e o valor da expressão em frente a palavra-chave <code>yield</code> é retornado para a chamada do generator. Ele pode ser considerado uma versão da palavra-chave <code>return</code> para o generator.</p>
+
+<p>A palavra-chave <code>yield</code> atualmente retorna um objeto do tipo <code>IteratorResult</code> com duas propriedades, <code>value</code> e <code>done</code>. A propriedade <code>value</code> é o resultado da avaliação da expressão <code>yield</code>, e <code>done</code> é <code>false</code>, indicando que a generator function não foi totalmente completada.</p>
+
+<p>Uma vez pausado em uma expressão <code>yield</code>, a execução do código do generator permanece pausado até a próxima chamada do métod <code>next()</code>. Cada vez que o método <code>next()</code> do generator é chamado, o generator resume a execução e roda até atingir um dos seguintes estados:</p>
+
+<ul>
+ <li> Um <code>yield</code>, que causa a pausa do generator novamente e retorna seu novo valor. Na próxima vez que <code>next()</code> for chamado, a execução resumirá com a declaração imediamente após <code>yield</code>.</li>
+ <li>{{jsxref("Statements/throw", "throw")}} é usado para invocar uma exception à partir do generator. Isso irá parar completamente a execução do generator, e a execução resume para onde foi chamado o generator normalmente no caso que uma exception é invocada.</li>
+ <li>O final de uma generator function é atingido; nesse caso, a execução do generator termina e um <code>IteratorResult</code> é retornado para onde o generator foi chamado no qual o <code>value</code> é {{jsxref("undefined")}} e <code>done</code> é <code>true</code>.</li>
+ <li>Uma declaração {{jsxref("Statements/return", "return")}} é atingida. Nesse caso, a execução do generator termina e um <code>IteratorResult</code> é retornado para onde o generator foi chamado no qual o <code>value</code> é o valor especificado pela declaração <code>return</code> statement e <code>done</code> é <code>true</code>.</li>
+</ul>
+
+<p>Se um valor opcional é passado para o método <code>next()</code> do generator, esse valor se torna o valor retornado pela operação <code>yield</code> atual do generator.</p>
+
+<p>Entre o caminho de código do generator, os seus operadores <code>yield</code>, e a habilidade de especificar um novo valor inicial passando isso para o {{jsxref("Generator.prototype.next()")}}, generators oferecem um poder e controle enormes</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>O código seguinte é a declaração de um exemplo de uma generator function.</p>
+
+<pre class="brush: js">function* foo() {
+  var index = 0;
+  while (index &lt;= 2)
+    yield index++;
+}</pre>
+
+<p>Uma vez que a generator function é definida, isso pode ser usada para construir um iterator como mostrado a seguir: </p>
+
+<pre class="brush: js">var iterator = foo();
+console.log(iterator.next()); // { value: 0, done: false }
+console.log(iterator.next()); // { value: 1, done: false }
+console.log(iterator.next()); // { value: 2, done: false }
+console.log(iterator.next()); // { value: undefined, done: true }</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#', 'Yield')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#', 'Yield')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>39</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("26.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+  <tr>
+   <td><code>IteratorResult</code> object instead of throwing</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoDesktop("29.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("26.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{ CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+  <tr>
+   <td><code>IteratorResult</code> object instead of throwing</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatGeckoMobile("29.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h2>
+
+<ul>
+ <li>A partir do Gecko 29 {{geckoRelease(29)}}, uma generator function completada não invoca mais um {{jsxref("TypeError")}} "generator has already finished". Ao invés, isso retorna um objeto <code>IteratorResult</code> como <code>{ value: undefined, done: true }</code> ({{bug(958951)}}).</li>
+ <li>A partir do Gecko 33 {{geckoRelease(33)}}, a análise (parsing) de uma expressão <code>yield</code> foi atualizada para se conformar com a especificação do ES2015 ({{bug(981599)}}):
+  <ul>
+   <li>A expressão após a palavra-chave <code>yield</code> é opcional e omitir isso não invoca mais um {{jsxref("SyntaxError")}}: <code>function* foo() { yield; }</code></li>
+  </ul>
+ </li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">O protocolo Iterator</a></li>
+ <li>{{jsxref("Statements/function*", "function*")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("Operators/yield*", "yield*")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/operators/yield_star_/index.html b/files/pt-br/web/javascript/reference/operators/yield_star_/index.html
new file mode 100644
index 0000000000..0c68b357d5
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/operators/yield_star_/index.html
@@ -0,0 +1,210 @@
+---
+title: yield*
+slug: Web/JavaScript/Reference/Operators/yield*
+tags:
+  - ECMAScript 2015
+  - Generators
+  - Iterable
+  - Iterator
+  - JavaScript
+  - Operador
+  - Operator
+  - Reference
+  - Referencia
+translation_of: Web/JavaScript/Reference/Operators/yield*
+---
+<div>{{jsSidebar("Operators")}}</div>
+
+<p>A <strong>expressão</strong> <strong><code>yield*</code> </strong>é usada para delegar para outro objeto {{jsxref("Statements/function*", "generator")}} ou iterable.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"> yield* [[expressão]];</pre>
+
+<dl>
+ <dt><code>expressão</code></dt>
+ <dd>A expressão que retorna um objeto iterable.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A expressão <code>yield*</code> itera sobre a operação e yields cada valor retornado por ele.</p>
+
+<p>O valor da expressão <code>yield*</code> sozinha é o valor retornado pelo iterator quando ele for fechado (i.e., quando <code>done</code> é <code>true</code>).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Delegando_para_outro_generator">Delegando para outro generator</h3>
+
+<p>No código seguinte, valores "yeldados" por <code>g1()</code> são retornados por <code>next()</code> chamam apenas os que foram "yeldados" por <code>g2()</code>.</p>
+
+<pre class="brush: js">function* g1() {
+  yield 2;
+  yield 3;
+  yield 4;
+}
+
+function* g2() {
+  yield 1;
+  yield* g1();
+  yield 5;
+}
+
+var iterator = g2();
+
+console.log(iterator.next()); // {value: 1, done: false}
+console.log(iterator.next()); // {value: 2, done: false}
+console.log(iterator.next()); // {value: 3, done: false}
+console.log(iterator.next()); // {value: 4, done: false}
+console.log(iterator.next()); // {value: 5, done: false}
+console.log(iterator.next()); // {value: undefined, done: true}
+</pre>
+
+<h3 id="Outros_objetos_Iterables">Outros objetos Iterables</h3>
+
+<p>Além de objetos generator, <code>yield*</code> também podem <code>yield</code> outros tipos de objetos iterables, e.g. arrays, strings ou objetos de argumentos.</p>
+
+<pre class="brush: js">function* g3() {
+  yield* [1, 2];
+  yield* '34';
+  yield* Array.from(arguments);
+}
+
+var iterator = g3(5, 6);
+
+console.log(iterator.next()); // {value: 1, done: false}
+console.log(iterator.next()); // {value: 2, done: false}
+console.log(iterator.next()); // {value: "3", done: false}
+console.log(iterator.next()); // {value: "4", done: false}
+console.log(iterator.next()); // {value: 5, done: false}
+console.log(iterator.next()); // {value: 6, done: false}
+console.log(iterator.next()); // {value: undefined, done: true}
+</pre>
+
+<h3 id="O_valor_da_expressão_yield*_sozinha">O valor da expressão <code>yield*</code> sozinha</h3>
+
+<p><code>yield*</code> é uma expressão, não uma declaração, então ele espera um valor.</p>
+
+<pre class="brush: js">function* g4() {
+  yield* [1, 2, 3];
+  return 'foo';
+}
+
+var result;
+
+function* g5() {
+  result = yield* g4();
+}
+
+var iterator = g5();
+
+console.log(iterator.next()); // {value: 1, done: false}
+console.log(iterator.next()); // {value: 2, done: false}
+console.log(iterator.next()); // {value: 3, done: false}
+console.log(iterator.next()); // {value: undefined, done: true},
+                              // g4() returned {value: 'foo', done: true} nesse ponto
+
+console.log(result);          // "foo"
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#', 'Yield')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#', 'Yield')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari (WebKit)</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoDesktop("27.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatGeckoMobile("27.0")}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatSafari("10")}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h2>
+
+<ul>
+ <li>A partir do Gecko 33 {{geckoRelease(33)}}, o tratamento da expressão yield foi atualizado para se conformar com a espeficação do ES2015 ({{bug(981599)}}):
+  <ul>
+   <li>A restrição de linha finalizadora agora está implementada. Nenhuma linha finalizadora entre "yield" e "*" é permitida. Código como o a seguir irá invocar uma exception {{jsxref("SyntaxError")}}:
+    <pre class="brush: js">function* foo() {
+  yield
+  *[];
+}</pre>
+   </li>
+  </ul>
+ </li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">O protocolo Iterator</a></li>
+ <li>{{jsxref("Statements/function*", "function*")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("Operators/yield", "yield")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/block/index.html b/files/pt-br/web/javascript/reference/statements/block/index.html
new file mode 100644
index 0000000000..6a86a4e7d7
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/block/index.html
@@ -0,0 +1,180 @@
+---
+title: block
+slug: Web/JavaScript/Reference/Statements/block
+tags:
+  - Declaração
+  - JavaScript
+  - Reference
+  - Statement
+translation_of: Web/JavaScript/Reference/Statements/block
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>Uma <strong>declaração em bloco </strong>(ou <strong>declaração composta (compound)</strong> em outras linguagens) é usado para agrupar nenhum ou mais declarações. O bloco é delimitado por um par de chaves e pode opcionalmente ser {{jsxref("Statements/label", "nomeado")}}:</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<h3 id="Declaração_de_Bloco">Declaração de Bloco</h3>
+
+<pre class="syntaxbox">{
+  <em>ListaDeDeclarações</em>
+}
+</pre>
+
+<h3 id="Declaração_de_Bloco_Nomeada">Declaração de Bloco Nomeada</h3>
+
+<pre class="syntaxbox"><em>NomeIdentificador</em>: {
+  <em>ListaDeDeclarações</em>
+}
+</pre>
+
+<dl>
+ <dt><code>ListaDeDeclarações</code></dt>
+ <dd>Declarações agroupadas com a declaração em bloco.</dd>
+ <dt><code>NomeIdentificador</code></dt>
+ <dd>Um {{jsxref("Statements/label", "nome (label)")}} opcional para identificação visual ou um alvo para {{jsxref("Statements/break", "break")}}.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A declaração em bloco é frequentemente chamada de <strong>declaração composta (compound)</strong> em outras linguagens. Ela permite que você use multiplas declarações onde o JavaScript espera apenas uma declaração. Combinar declarações em blocos são uma prática comum em JavaScript. O comportamento oposto é possível usando uma <a href="/en-US/docs/Web/JavaScript/Reference/Statements/Empty">declaração vazia</a>, onde você fornece nenhuma declaração, mesmo que uma seja requerida.</p>
+
+<h3 id="Regras_de_Bloqueio_de_Escopo">Regras de Bloqueio de Escopo</h3>
+
+<h4 id="Com_var">Com <code>var</code></h4>
+
+<p>Variáveis declaradas com <code>var</code> <strong>não</strong> possuem bloqueio de escopo. Variáveis introduzidas com um bloco são guardadas no escopo da função que elas estão ou script, e os efeitos de configura-las persistem pelo próprio bloco. Em outras palavras, declarações em bloco não introduzem um escopo. Mesmo blocos "standalone" são sintaxes válidas, você não vai querer usar blocos standalone em JavaScript, porque não fazem o que você pensa que eles fazem, se você pensa que eles fazer coisas como blocos em C ou Java. Por exemplo:</p>
+
+<pre class="brush: js example-bad">var x = 1;
+{
+  var x = 2;
+}
+console.log(x); // imprime 2
+</pre>
+
+<p>Isso loga 2 porque a declaração <code>var x</code> com o bloco está no mesmo escopo que a declaração <code>var x</code> antes do bloco. No C ou Java, o código equivalente iria imprimir 1.</p>
+
+<h4 id="Com_let_e_const">Com <code>let e</code> <code>const</code></h4>
+
+<p>Por contraste, variáveis declaradas com {{jsxref("Statements/let", "let")}} e {{jsxref("Statements/const", "const")}} <strong>tem </strong>escopo bloqueado:</p>
+
+<pre class="brush: js">let x = 1;
+{
+  let x = 2;
+}
+console.log(x); // imprime 1 1</pre>
+
+<p><code><font face="Open Sans, arial, x-locale-body, sans-serif">O </font>x = 2</code> é limitado ao escopo do bloco em que ele foi definido.</p>
+
+<p>O mesmo true de <code>const</code>:</p>
+
+<pre class="brush: js">const c = 1;
+{
+  const c = 2;
+}
+console.log(c); // imprime 1 e não invoca uma throw SyntaxError...</pre>
+
+<p>Note que o escope bloqueado de <code>const c = 2</code> <em>não invoca uma</em> <code>SyntaxError: Identifier 'c' has already been declared</code> porque ele foi unicamente declarado no bloco.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-block', 'Block statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-block', 'Block statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.1', 'Block statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-12.1', 'Block statement')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-12.1', 'Block statement')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>
+    <p>Definição inicial. Implementada no JavaScript 1.0.</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/while", "while")}}</li>
+ <li>{{jsxref("Statements/if...else", "if...else")}}</li>
+ <li>{{jsxref("Statements/let", "let")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/break/index.html b/files/pt-br/web/javascript/reference/statements/break/index.html
new file mode 100644
index 0000000000..1eb3e24b03
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/break/index.html
@@ -0,0 +1,159 @@
+---
+title: break
+slug: Web/JavaScript/Reference/Statements/break
+translation_of: Web/JavaScript/Reference/Statements/break
+---
+<div>
+<div>{{jsSidebar("Statements")}}</div>
+</div>
+
+<h2 id="Sumário">Sumário</h2>
+
+<p>O comando <strong>break </strong>encerra o loop atual, {{jsxref("Statements/switch", "switch")}}, ou o loop que foi informado no {{jsxref("Statements/label", "label")}} e transfere o controle da execução do programa para o comando seguinte.</p>
+
+<h2 id="Síntaxe">Síntaxe</h2>
+
+<pre class="syntaxbox"><code>break [label];</code></pre>
+
+<dl>
+ <dt><code>label</code></dt>
+ <dd>Opcional. Identificador associado ao label de um comando. Se a estrutura não for um loop ou {{jsxref("Statements/switch", "switch")}}, ele será um pré-requisito.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O comando <code>break</code> inclui um label opcional que permite ao programa encerrar a execução da estrutura que possui o nome informado na label. O comando <code>break</code> deve estar dentro dessa estrutura informada no label. A estrutura que possui o nome informada na label pode ser qualquer comando {{jsxref("Statements/block", "block")}}; não é necessário que seja precedida por um loop.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>A função a seguir possui um comando <code>break</code> que encerra o loop  {{jsxref("Statements/while", "while")}} quando a variável i vale 3, e então retorna o valor 3 * <code>x</code>.</p>
+
+<pre class="brush:js;highlight:[6];">function testaBreak(x) {
+   var i = 0;
+
+   while (i &lt; 6) {
+      if (i == 3) {
+         break;
+      }
+      i += 1;
+   }
+   return i * x;
+}</pre>
+
+<p>O código a seguir possui o comando break dentro de uma estrutura nomeada. O comando <code>break</code> deverá estar dentro da estrutura na qual o label se refere. Veja que  <code>inner_block</code> está dentro de <code>outer_block</code>.</p>
+
+<pre class="brush:js;highlight:[1,3,5];">bloco_externo:{
+
+  bloco_interno:{
+    console.log ('1');
+    break bloco_externo;      // encerra bloco_interno e bloco_externok
+    console.log (':-(');    // não é executado
+  }
+
+  console.log ('2');        // não é executado
+}
+</pre>
+
+<p>O código a seguir também utiliza o comando break com blocos nomeados mas gera um erro de sintaxe pois o comando break está dentro do bloco_1 mas faz uma referência ao bloco_2. Um comando break sempre deverá estar dentro da estrutura nomeada na qual fizer referência.</p>
+
+<pre class="brush:js;highlight:[1,3,6];">bloco_1:{
+  console.log ('1');
+  break bloco_2;            // SyntaxError: label not found
+}
+
+bloco_2:{
+  console.log ('2');
+}
+</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>ECMAScript 1st Edition</td>
+   <td>Standard</td>
+   <td>Definição inicial. Versão sem o uso do label.</td>
+  </tr>
+  <tr>
+   <td>ECMAScript 3rd Edition</td>
+   <td>Standard</td>
+   <td>Versão com label adicionada.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.8', 'Break statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-break-statement', 'Break statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/continue", "continue")}}</li>
+ <li>{{jsxref("Statements/label", "label")}}</li>
+ <li>{{jsxref("Statements/switch", "switch")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/class/index.html b/files/pt-br/web/javascript/reference/statements/class/index.html
new file mode 100644
index 0000000000..4a07ded20f
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/class/index.html
@@ -0,0 +1,85 @@
+---
+title: class
+slug: Web/JavaScript/Reference/Statements/class
+tags:
+  - Classes
+  - Declaração
+  - ES2015
+  - ES6
+  - Estático
+  - JavaScript
+  - Static
+translation_of: Web/JavaScript/Reference/Statements/class
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<div>A <strong>declaração class</strong> cria uma nova classe com dado <strong>nome </strong>usando a herança do protótipo base.</div>
+
+<p> </p>
+
+<p>Você também pode definir uma classe usando {{jsxref("Operators/class", "class expression", "", 1)}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="brush: js">class <em>name</em> [extends] {
+  // class body
+}
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Assim como as expressões de classe, o corpo de uma declaração de classe é executado em <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Strict_mode">strict mode</a>.</p>
+
+<p>Declarações de classe não são {{Glossary("Hoisting", "hoisted")}} (ao contrário de <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function declarations</a>).</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Declaração_simples_de_classe">Declaração simples de classe</h3>
+
+<p>No exemplo a seguir, primeiro definimos uma classe chamada <em>Polygon</em>, então extendemos essa classe para criar uma classe chamada <em>Square</em>. Note que <em>super()</em>, usada no construtor, só pode ser usada em construtores e deve ser chamada antes da chave <em>this</em> ser usada.</p>
+
+<pre class="brush: js">class Poligono {
+  constructor(altura, largura) {
+    this.nome = 'Polígono';
+    this.altura = altura;
+    this.largura = largura;
+  }
+}
+
+class Quadrado extends Poligono {
+  constructor(altura) {
+    super(altura, altura);
+    this.nome = 'Quadrado';
+  }
+}</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-class-definitions', 'Class definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browser">Compatibilidade de Browser</h2>
+
+
+
+<p>{{Compat("javascript.statements.class")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/function"><code>function</code> declaration</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/class"><code>class</code> expression</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Classes">Classes</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/const/index.html b/files/pt-br/web/javascript/reference/statements/const/index.html
new file mode 100644
index 0000000000..64aa4c2fc6
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/const/index.html
@@ -0,0 +1,224 @@
+---
+title: const
+slug: Web/JavaScript/Reference/Statements/const
+tags:
+  - ECMAScript6
+  - ES6
+  - JavaScript
+  - Referencia
+  - constantes
+translation_of: Web/JavaScript/Reference/Statements/const
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>Constantes possuem escopo de bloco, semelhantes às variáveis declaradas usando o palavra-chave <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code>. O valor de uma constante não pode ser alterado por uma atribuição, e ela não pod ser redeclarada.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/statement-const.html")}}</div>
+
+<div class="hidden">O código-fonte deste exempllo interativo está armazenado em um repositório do GitHub. Se você desejar contribuir para o projeto de exemplos interativos, por favor, clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e nos envie um pull request.</div>
+
+<h2 id="Summary" name="Summary">Resumo</h2>
+
+<p>A <strong> declaração <code>const</code></strong> cria uma variável cujo o valor é fixo, ou seja, uma constante somente leitura. Isso não significa que o valor é imutável, apenas que a variável constante não pode ser alterada ou retribuída.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">const <em>name1 = <em>value1 [</em>, <em>name2</em> = <em>value2</em><em> [</em>, ... [</em>, <em>nameN</em> = <em>valueN]]]]</em>;</pre>
+
+<dl>
+ <dt><code>nameN</code></dt>
+ <dd>Nome da constante. Pode ser qualquer <a href="https://developer.mozilla.org/en-US/docs/Glossary/Identifier"> identificador </a> válido.</dd>
+ <dt><code>valueN</code></dt>
+ <dd>Valor atribuido a constante. Pode ser qualquer <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Expressions">expressão </a> válida, incluindo uma função.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Esta declaração cria uma constante que pode pertencer tanto ao escopo global (na janela ou objeto) quanto ao local do bloco em que é declarada. Constantes globais não se tornam propriedades do objeto <code>window</code>, diferente da criação de variáveis com <code>var</code>.</p>
+
+<p>Toda constante requer um inicializador, ou seja, é preciso especificar um valor para a constante no momento em que ela é declarada (o que faz sentido, uma vez que esse valor não pode ser alterado).</p>
+
+<p>A declaração <strong><code>const</code> </strong>cria uma referência somente leitura a um valor. Isso <strong>não </strong>significa que esse valor é imutável, apenas que o identificador da variável constante não pode ser alterado. Se o conteúdo do identificador for um objeto, isso significa que o conteúdo do objeto (ex. seus parâmetros) podem ser alterados.</p>
+
+<p>Todas as considerações de <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let#Temporal_dead_zone_and_errors_with_let">"temporal dead zone"</a> se aplicam tanto a <strong><code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let">let</a></code></strong> quanto a <strong><code>const</code></strong>.</p>
+
+<p>Uma constante não pode ter o mesmo nome que uma função ou variável que esteja no mesmo escopo.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<p>O exemplo abaixo demonstra o comportamento de uma constante. Experimente executá-lo no console do seu navegador.</p>
+
+<pre class="brush:js notranslate">// NOTA: constantes podem ser declaradas em caixa alta ou baixa,
+// mas uma convenção comum é usar apenas caixa alta
+
+// define MY_FAV como uma constante e lhe atribui o valor 7
+const MY_FAV = 7;
+
+// isto falha mas não emite erros no Firefox e Chrome (porém não falha no Safari)
+MY_FAV = 20;
+
+// a variável MY_FAV possui o valor 7
+console.log("my favorite number is: " + MY_FAV);
+
+// tentar redeclarar a constante emite um erro - Uncaught SyntaxError: Identifier 'MY_FAV' has already been declared
+const MY_FAV = 20;
+
+// o nome MY_FAV está reservado para a constante acima, logo também irá falhar
+var MY_FAV = 20;
+
+// isso também vai falhar
+let MY_FAV = 20;
+
+// É importante notar a natureza de escopo por bloco
+if (MY_FAV === 7) {
+    // não tem problema fazer isso, pois cria uma variável de bloco MY_FAV
+    // com escopo local (o nome MY_FAV poderia ser usado com let também)
+    let MY_FAV = 20;
+
+    // MY_FAV agora é 20
+    console.log("meu número favorito é " + MY_FAV);
+
+    // isso retorna um erro, pois tenta registrar a variável no contexto global
+    var MY_FAV = 20;
+}
+
+//MY_FAV ainda é 7
+console.log('meu número favorito é ' + MY_FAV);
+
+// const deve ser inicializada
+const FOO; // SyntaxError: missing = in const declaration
+
+// const também funciona com objetos
+const MY_OBJECT = {'key':'value'};
+
+// Sobrescrever o objeto também falha (no Firefox e Chrome mas não no Safari) - Uncaught TypeError: Assignment to constant variable.
+MY_OBJECT = {"OTHER_KEY": "value"};
+
+// Entretanto, atributos de objetos não estão protegidos,
+// logo a seguinte instrução é executada sem problemas
+MY_OBJECT.key = "otherValue"; // Utilize Object.freeze() se quiser tornar um objeto imutável
+
+// o mesmo se aplica para arrays
+const MY_ARRAY = [];
+// É possível utilizar push para incluir itens no array
+MY_ARRAY.push('A'); //["A"]
+// Todavia, atribuir um novo array para a variável gera um erro
+MY_ARRAY = ['B'];
+</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-let-and-const-declarations', 'Let and Const Declarations')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Nenhuma mudança.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-let-and-const-declarations', 'Let and Const Declarations')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>36.0 (maybe earlier)</td>
+   <td>IE11</td>
+   <td>12.00 (maybe earlier)</td>
+   <td>5.1.7 (maybe earlier)</td>
+  </tr>
+  <tr>
+   <td>
+    <p>Reassignment fails</p>
+   </td>
+   <td>{{ CompatChrome(20) }}</td>
+   <td>{{ CompatGeckoDesktop(13) }}</td>
+   <td>IE11</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Reassignment fails</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h3 id="Observações">Observações</h3>
+
+<p>Em versões anteriores do Firefox &amp; Chrome e a partir de Safari 5.1.7 e Opera 12.00, se você define uma variável com <code>const</code>, você ainda consegue alterar o valor depois. Este recurso não é suportado no Internet Explorer 6-10, mas está incluído no Internet Explorer 11.</p>
+
+<h3 id="Observações_específicas_para_Firefox">Observações específicas para Firefox</h3>
+
+<p> A declaração <code>const</code> foi implementada no Firefox muito antes de <code>const</code> aparecer na especificação ECMAScript 6. For <code>const</code> ES6 compliance see {{bug(950547)}} and {{bug(611388)}}.</p>
+
+<ul>
+ <li>Iniciando com o Gecko 36 {{geckoRelease("36")}}:
+  <ul>
+   <li><code>{const a=1};a</code> passa a retornar <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ReferenceError" title="The ReferenceError object represents an error when a non-existent variable is referenced."><code>ReferenceError</code></a> e não retorna <code>1</code> devido block-scoping.</li>
+   <li><code>const a;</code> passa a retornar <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError" title="The SyntaxError object represents an error when trying to interpret syntactically invalid code."><code>SyntaxError</code></a> ("missing = in const declaration<code>"</code>): É necessário incializar a constante.</li>
+   <li><code>const a = 1; a = 2;</code> passa a retornar <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError" title="The SyntaxError object represents an error when trying to interpret syntactically invalid code."><code>SyntaxError</code></a> ("invalid assignment to const a").</li>
+  </ul>
+ </li>
+</ul>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/var"><code>var</code></a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Values,_variables,_and_literals#Constants">Guia de constantes em JavaScript</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/continue/index.html b/files/pt-br/web/javascript/reference/statements/continue/index.html
new file mode 100644
index 0000000000..7bb4497634
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/continue/index.html
@@ -0,0 +1,206 @@
+---
+title: continue
+slug: Web/JavaScript/Reference/Statements/continue
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Statements/continue
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A palavra chave <strong>continue</strong> termina a atual iteração do laço em que ele se encontra ou de um laço rotulado, e continua a execução deste laço com a próxima iteração.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">continue [<em>rótulo</em>];</pre>
+
+<dl>
+ <dt><code>rótulo</code></dt>
+ <dd>Identificador associado ao laço.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Diferentemente do  {{jsxref("Statements/break", "break")}}, o <code>continue</code> não termina a execução do laço completamente, em vez disso ele:</p>
+
+<ul>
+ <li>Volta à condição, em um laço do tipo {{jsxref("Statements/while", "while")}}.</li>
+</ul>
+
+<ul>
+ <li>Volta à expressão, atualizando-a, em um laço do tipo {{jsxref("Statements/for", "for")}}.</li>
+</ul>
+
+<p>O <code>continue</code> pode incluir, opcionalmente, um rótulo que premite ao programa pular para a próxima iteração de um laço rotulado em vez de pular o loop em que ele se encontra. Neste caso, o <code>continue</code> necessita estar dentro deste laço rotulado.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_continue_com_while">Usando <code>continue</code> com <code>while</code></h3>
+
+<p>O exemplo abaixo mostra um laço {{jsxref("Statements/while", "while")}} que tem um  <code>continue</code> que será executado quando o valor de <code>i</code> for 3. Assim, <code>n</code> terá os valores 1, 3, 7, e 12.</p>
+
+<pre class="brush: js">var i = 0;
+var n = 0;
+
+while (i &lt; 5) {
+  i++;
+
+  if (i === 3) {
+    continue;
+  }
+
+  n += i;
+}
+</pre>
+
+<h3 id="Usando_o_continue_com_um_rótulo">Usando o <code>continue</code> com um rótulo</h3>
+
+<p>No exemplo abaixo, um laço rotulado como <code>checkiandj</code> contém o laço rotulado <code>checkj</code>. Se o <code>continue</code> for alcançado, o programa continua a execução voltando ao topo do rótulo <code>checkj</code>. Cada vez que o <code>continue</code> for alcançado, <code>checkj</code> reiterará até sua condição for falsa. Quando retornar <code>false</code>, o restante de <code>checkiandj</code> será executado.</p>
+
+<p>Se o <code>continue</code> tivesse o rótulo <code>checkiandj</code>, o programa iria continuar retornando a execução ao label <code>checkiandj</code>.</p>
+
+<p>Veja também {{jsxref("Statements/label", "label")}}.</p>
+
+<pre class="brush: js">var i = 0;
+var j = 8;
+
+checkiandj: while (i &lt; 4) {
+  console.log("i: " + i);
+  i += 1;
+
+  checkj: while (j &gt; 4) {
+    console.log("j: "+ j);
+    j -= 1;
+
+    if ((j % 2) == 0)
+      continue checkj;
+    console.log(j + " is odd.");
+  }
+  console.log("i = " + i);
+  console.log("j = " + j);
+}
+</pre>
+
+<p>Output:</p>
+
+<pre class="brush: js">"i: 0"
+
+// start checkj
+"j: 8"
+"7 is odd."
+"j: 7"
+"j: 6"
+"5 is odd."
+"j: 5"
+// end checkj
+
+"i = 1"
+"j = 4"
+
+"i: 1"
+"i = 2"
+"j = 4"
+
+"i: 2"
+"i = 3"
+"j = 4"
+
+"i: 3"
+"i = 4"
+"j = 4"
+</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ários</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial. Versão sem rótulo.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Versão rotulada adicionada.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.7', 'Continue statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-continue-statement', 'Continue statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-continue-statement', 'Continue statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/break", "break")}}</li>
+ <li>{{jsxref("Statements/label", "label")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/debugger/index.html b/files/pt-br/web/javascript/reference/statements/debugger/index.html
new file mode 100644
index 0000000000..c8e428e365
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/debugger/index.html
@@ -0,0 +1,71 @@
+---
+title: debugger
+slug: Web/JavaScript/Reference/Statements/debugger
+translation_of: Web/JavaScript/Reference/Statements/debugger
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A <strong>declaração debug</strong> invoca qualquer funcionalidade de depuração disponivel, como definir um breakpoint. Se nenhuma funcionalidade de depuração estiver disponivel, essa declaração não tem nenhum efeito.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>debugger;</code></pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>O exemplo a seguir mostra o código onde uma declaração debugger foi inserida para invocar um depurador (se um existir) quando a função for chamada.</p>
+
+<pre class="brush:js">function codigoPotencialmenteBugado() {
+    debugger;
+    // faça atividades de depuração como examinar, pular um passo etc.
+}
+</pre>
+
+<p>Quando o depurador é invocado, a execução é parada na declaração debugger. É como um breakpoint no código-fonte.</p>
+
+<p><a href="https://mdn.mozillademos.org/files/6963/Screen Shot 2014-02-07 at 9.14.35 AM.png"><img alt="Paused at a debugger statement." src="https://mdn.mozillademos.org/files/6963/Screen%20Shot%202014-02-07%20at%209.14.35%20AM.png" style="height: 371px; width: 700px;"></a></p>
+
+<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-debugger-statement', 'Debugger statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.15', 'Debugger statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição Inicial</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-7.5.3', 'Debugger statement')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-7.4.3', 'Debugger statement')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>
+    <p>Apenas mencioado como uma palavra reservada.</p>
+   </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<p>{{Compat("javascript.statements.debugger")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Debugging_JavaScript">Depurando JavaScript </a></li>
+ <li><a href="/en-US/docs/Tools/Debugger">O Depurador nas Ferramentas de Desenvolvedor do Firefox </a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/default/index.html b/files/pt-br/web/javascript/reference/statements/default/index.html
new file mode 100644
index 0000000000..fb84ae5e9e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/default/index.html
@@ -0,0 +1,186 @@
+---
+title: default
+slug: Web/JavaScript/Reference/Statements/default
+tags:
+  - JavaScript
+  - Keyword
+  - Palavra-chave
+translation_of: Web/JavaScript/Reference/Statements/switch
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A <strong>palavra-chave default </strong>pode ser usada em duas situações no JavaScript: com uma declaração {{jsxref("Statements/switch", "switch")}}, ou com uma declaração {{jsxref("Statements/export", "export")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<p>Com uma declaração {{jsxref("Statements/switch", "switch")}}:</p>
+
+<pre class="syntaxbox">switch (expressao) {
+  case value1:
+    //Declarações executadas quando o resultado da expressao for value1
+    [break;]
+  default:
+    //Declarações executadas quando nenhum dos valores for igual o da expressao
+    [break;]
+}</pre>
+
+<p>Com a declaração {{jsxref("Statements/export", "export")}}:</p>
+
+<pre class="syntaxbox">export default <em>nameN</em> </pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Para mais detalhes, veja as páginas:</p>
+
+<ul>
+ <li>Declaração {{jsxref("Statements/switch", "switch")}}</li>
+ <li>Declaração {{jsxref("Statements/export", "export")}}.</li>
+</ul>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_default_em_declarações_switch">Usando <code>default</code> em declarações <code>switch</code></h3>
+
+<p>No exemplo a seguir, se a variável <code>expr</code> for "Laranjas" ou "Maças", o programa encontra os valores com o case "Laranjas" ou "Maças"  e executa a declaração correspondente. A palavra-chave <code>default</code> vai ajudar em qualquer outro caso e executará a declaração associada.</p>
+
+<pre class="brush: js">switch (expr) {
+  case 'Laranjas':
+    console.log('Laranjas custam R$0,59.');
+    break;
+  case 'Maças':
+    console.log('Maças custam R$0,32.');
+    break;
+  default:
+    console.log('Desculpe, nós não temos ' + expr + '.');
+}</pre>
+
+<h3 id="Usando_default_com_export">Usando <code>default</code> com <code>export</code></h3>
+
+<p>Se você quiser exportar apenas um valor ou precisa de um valor fallback para um módulo, uma exportação padrão (default export) pode ser usada:</p>
+
+<pre class="brush: js">// module "my-module.js"
+let cube = function cube(x) {
+  return x * x * x;
+};
+export default cube;</pre>
+
+<p>Então, no outro script, isso pode ser passado direto para o import do default export:</p>
+
+<pre class="brush: js">// module "my-module.js"
+import myFunction from 'my-module';
+console.log(myFunction(3)); // 27
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-exports', 'Exports')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-switch-statement', 'switch statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-exports', 'Exports')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Switch default</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Export default</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Switch default</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+  <tr>
+   <td>Export default</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/export", "export")}}</li>
+ <li>{{jsxref("Statements/switch", "switch")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/do...while/index.html b/files/pt-br/web/javascript/reference/statements/do...while/index.html
new file mode 100644
index 0000000000..a9396d0e82
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/do...while/index.html
@@ -0,0 +1,138 @@
+---
+title: do...while
+slug: Web/JavaScript/Reference/Statements/do...while
+translation_of: Web/JavaScript/Reference/Statements/do...while
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<div></div>
+
+<div>A declaração <strong><code>do...while</code><code> </code></strong>cria um laço que executa uma declaração até que o teste da condição for falsa (false). A condição é avaliada depois que o bloco de código é executado, resultando que uma declaração seja executada pelo menos uma vez.</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">do
+   <em>statement</em>
+while (<em>condition</em>);
+</pre>
+
+<dl>
+ <dt><code>declarações</code></dt>
+ <dd>A declaração é executada pelo menos uma vez e re-executada cada vez que a condição (<code>condition</code>) for avaliada como verdadeira (true). Para executar múltiplas declarações dentro do laço, use um {{jsxref("declaração/block", "block")}} declaração (<code>{ ... }</code>) ao grupo dessas declarações.</dd>
+</dl>
+
+<dl>
+ <dt><code>condição</code></dt>
+ <dd>Uma expressão é validade depois de cada passagem pelo laço. Se a condição <code>(condition) </code>é avaliada como verdadeira (true) o bloco de código é executado novamente. Quando a condição <code>(condition) </code>é avaliada como falsa (false),  o controle passa para a instrução seguinte ao laço <strong>do...while</strong>.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_do...while">Usando <code>do...while</code></h3>
+
+<p>No exemplo seguinte, o laço <strong>do...while</strong> soma pelo menos uma vez e executa novamente até <code>i</code> não ser menor que 5.</p>
+
+<h3 id="Conteúdo_HTML">Conteúdo HTML </h3>
+
+<pre class="brush: html">&lt;div id="exemplo"&gt;&lt;/div&gt;</pre>
+
+<h3 id="Conteúdo_JavaScript">Conteúdo JavaScript </h3>
+
+<pre class="brush: js">var resultado = '';
+var i = 0;
+do {
+   i += 1;
+   resultado += i + ' ';
+} while (i &lt; 5);
+document.getElementById('exemplo').innerHTML = resultado;</pre>
+
+<h3 id="Resultado">Resultado</h3>
+
+<p>{{ EmbedLiveSample('Exemplos') }}</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 3rd Edition.</td>
+   <td>Standard</td>
+   <td>Initial definition.<br>
+    Implemented in JavaScript 1.2</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.6.1', 'do-while statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-do-while-statement', 'do-while statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Trailing ; is now optional.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_do_navegador">Compatibilidade do navegador</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>IE6+</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/while", "while")}}</li>
+ <li>{{jsxref("Statements/for", "for")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/empty/index.html b/files/pt-br/web/javascript/reference/statements/empty/index.html
new file mode 100644
index 0000000000..e0570b0af1
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/empty/index.html
@@ -0,0 +1,80 @@
+---
+title: empty
+slug: Web/JavaScript/Reference/Statements/Empty
+translation_of: Web/JavaScript/Reference/Statements/Empty
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>Uma <strong>declaração vazia</strong> é usada para fornecer nenhuma declaração, embora a sintaxe do JavaScript esperasse uma.</p>
+
+<div>{{EmbedInteractiveExample("pages/js/statement-empty.html")}}</div>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">;
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A instrução vazia é um ponto-e-vírgula (;) indicando que nenhuma instrução será executada, mesmo se a sintaxe do JavaScript exigir uma.</p>
+
+<p>O comportamento oposto, em que você deseja várias instruções, mas o JavaScript permite apenas uma única, é possível usando uma <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block">instrução de bloco</a> ; combina várias declarações em uma única.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>A instrução vazia às vezes é usada com instruções de loop. Veja o exemplo a seguir com um corpo de loop vazio:</p>
+
+<pre class="brush: js notranslate">var arr = [1, 2, 3];
+
+// Assign all array values to 0
+for (i = 0; i &lt; arr.length; arr[i++] = 0) /* empty statement */ ;
+
+console.log(arr)
+// [0, 0, 0]
+</pre>
+
+<p><strong>Nota:</strong> É uma boa ideia comentar o uso intencional da declaração vazia, pois não é realmente óbvio distinguir entre um ponto e vírgula normal. No exemplo a seguir, o uso provavelmente não é intencional:</p>
+
+<pre class="brush: js notranslate">if (condition);       // Caution, this "if" does nothing!
+   killTheUniverse()  // So this gets always executed!!!
+</pre>
+
+<p>Outro Exemplo: Uma declaração <a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else"><code>if...else</code></a> declaração sem chaves ({ }). Se três for verdadeiro, nada acontecerá, quatro não importa e também a função launchRocket ( ) no caso contrário não será executada.</p>
+
+<pre class="brush: js notranslate">if (one)
+  doOne();
+else if (two)
+  doTwo();
+else if (three)
+  ; // nothing here
+else if (four)
+  doFour();
+else
+  launchRocket();</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificações</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-empty-statement', 'Empty statement')}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browsers_compatíveis">Browsers compatíveis</h2>
+
+
+
+<p>{{Compat("javascript.statements.empty")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/block", "Block statement")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/export/index.html b/files/pt-br/web/javascript/reference/statements/export/index.html
new file mode 100644
index 0000000000..f429a13988
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/export/index.html
@@ -0,0 +1,223 @@
+---
+title: export
+slug: Web/JavaScript/Reference/Statements/export
+translation_of: Web/JavaScript/Reference/Statements/export
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>O export é utilizado quando criamos módulos JavaScript para exportar ligações em tempo real para suas funções, objetos ou valores primitivos de um módulo sejam utilizados por outros programas através de declarações {{jsxref("Statements/import", "import")}}. Ligações que são exportadas ainda podem ser modificadas localmente; quando importadas, embora elas possam ser lidas somente pelo módulo que as importou, seu valor é atualizado sempre que ela modificada pelo módulo que a exportou.</p>
+
+<p>Módulos exportados ficam em {{jsxref("Strict_mod", "strict mode")}}, independentemente se é declarado dessa forma, ou não. Export não pode ser utilizado em scripts embutidos.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<p>Há dois tipos de exportação:</p>
+
+<ol>
+ <li>Exportações Explícitas (Named Exports) (Zero ou mais exports por módulo)</li>
+ <li>Exportações Padrão (Default Exports) (Uma por módulo)</li>
+</ol>
+
+<pre class="syntaxbox notranslate">// Exportando recursos individuais
+export let <var>name1</var>, <var>name2</var>, …, <var>nameN</var>; // também var, const
+export let <var>name1</var> = …, <var>name2</var> = …, …, <var>nameN</var>; // também var, const
+export function functionName(){...}
+export class ClassName {...}
+
+// Lista de exportações
+export { <var>name1</var>, <var>name2</var>, …, <var>nameN</var> };
+
+// Renomeando exports
+export { <var>variable1</var> as <var>name1</var>, <var>variable2</var> as <var>name2</var>, …, <var>nameN</var> };
+
+// Exportando atribuições desestruturadas renomeando
+export const { <var>name1</var>, <var>name2: bar</var> } = o;
+
+// Exportações Padrão (Default exports)
+export default <em>expression</em>;
+export default function (…) { … } // também class, function*
+export default function name1(…) { … } // também class, function*
+export { <var>name1</var> as default, … };
+
+// Agregando módulos
+export * from …; // não define a exportação padrão
+export * as name1 from …; // Draft ECMAScript® 2O21
+export { <var>name1</var>, <var>name2</var>, …, <var>nameN</var> } from …;
+export { <var>import1</var> as <var>name1</var>, <var>import2</var> as <var>name2</var>, …, <var>nameN</var> } from …;
+export { default } from …;</pre>
+
+<dl>
+ <dt><code>nameN</code></dt>
+ <dd>Identificador para ser exportado (assim ele pode ser importado via <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/import">import</a></code> em outro script).</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Há dois diferentes tipos de export, explícito(named) e padrão(default).  Pode-se ter várias exportações explícitas por módulo, mas apenas uma padrão. Cada tipo corresponde à uma da síntaxe acima:</p>
+
+<p>Exportações explícitas:</p>
+
+<pre class="brush: js notranslate">// exporta recursos declarados anteriomente
+export { myFunction, myVariable };
+
+// exporta recursos individuais (pode exportar var, let,
+// const, function, class)
+export let myVariable = Math.sqrt(2);
+export function myFunction() { ... };</pre>
+
+<p>Exportação padrão (pode ser feita apenas uma por script):</p>
+
+<pre class="brush: js notranslate">// exporta um recurso declarado anteriormente como padrão
+export { myFunction as default };
+
+// exporta recursos individuais como padrão
+export default function () { ... }
+export default class { .. }</pre>
+
+<p>Exportações explícitas são úteis para exportar vários valores. Durante a importação, é obrigatório usar o mesmo nome do objeto correspondente.</p>
+
+<p>Mas a exportação padrão pode ser importada com qualquer nome, por exemplo:</p>
+
+<pre class="brush: js notranslate">// arquivo test.js
+let k; export default k = 12;
+</pre>
+
+<pre class="brush: js notranslate">// algum outro arquivo
+import m from './test'; // note que temos a liberdade de usar import m ao invés de import k, porque k era uma exportaçào padrão
+console.log(m);        // vai retornar log 12
+</pre>
+
+<p>Você também pode renomear exportações explícitas para evitar conflitos e nome:</p>
+
+<pre class="brush: js notranslate">export { <var>myFunction</var> as <var>function1</var>,<var>
+         myVariable</var> as variable };</pre>
+
+<h3 id="Re-exportando_Agregando">Re-exportando / Agregando</h3>
+
+<p>É possível também "importar/exportar" de módulos diferentes em um módulo pai, de modo que eles estejam disponíveis para serem importados daquele módulo. Em outras palavras, pode-se criar um módulo único concentrando várias exportações de vários módulos.</p>
+
+<p>Isto pode ser feito com a sintaxe "export from":</p>
+
+<pre class="brush: js notranslate">export { default as function1,
+         function2 } from 'bar.js';
+</pre>
+
+<p>O que é comparável com um combinação de import e export:</p>
+
+<pre class="brush: js notranslate">import { default as function1,
+         function2 } from 'bar.js';
+export { function1, function2 };
+</pre>
+
+<p>Mas onde <code>function1</code> e <code>function2</code> não ficam disponíveis dentro do módulo atual.</p>
+
+<div class="blockIndicator note">
+<p><strong>Nota:</strong> Os exemplos a seguir são sintaticamente inválidos apesar de sua equivalência com o import:</p>
+</div>
+
+<pre class="brush: js notranslate">import DefaultExport from 'bar.js'; // Válido
+</pre>
+
+<pre class="brush: js notranslate">export DefaultExport from 'bar.js'; // Inválido</pre>
+
+<p>O modo correto de fazer isso e renomeando o export:</p>
+
+<pre class="brush: js notranslate">export { default as DefaultExport } from 'bar.js';
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_exportações_explícitas">Usando exportações explícitas</h3>
+
+<p>Em um módulo <code>my-module.js</code> poderiamos usar o seguinte código:</p>
+
+<pre class="brush: js notranslate">// módulo "my-module.js"
+function cube(x) {
+  return x * x * x;
+}
+
+const foo = Math.PI + Math.SQRT2;
+
+var graph = {
+  options: {
+      color:'white',
+      thickness:'2px'
+  },
+  draw: function() {
+      console.log('Da função draw de graph');
+  }
+}
+
+export { cube, foo, graph };</pre>
+
+<p>Então, no módulo principal incluído sem sua página HTML, poderíamos ter:</p>
+
+<pre class="brush: js notranslate">import { cube, foo, graph } from './my-module.js';
+
+graph.options = {
+    color:'blue',
+    thickness:'3px'
+};
+
+graph.draw();
+console.log(cube(3)); // 27
+console.log(foo);    // 4.555806215962888</pre>
+
+<p>É importante notar o seguinte:</p>
+
+<ul>
+ <li>Você pode incluir esse script no seu código HTML através do elemento {{htmlelement("script")}} do tipo="module", de modo que ele seja reconhecido e tratado apropriadamente.</li>
+ <li>Você não pode executar módulos JS através de <code>file://</code> URL — você receberá errors <a href="https://wiki.developer.mozilla.org/en-US/docs/Web/HTTP/CORS">CORS</a>. Você deve rodá-los através de um servidor HTTP.</li>
+</ul>
+
+<h3 id="Usando_a_exportação_padrão">Usando a exportação padrão</h3>
+
+<p>Se queremos exportar um valor sozinho ou obter um valor de reserva para o nosso módulo, nós poderiamos usar <code>export default</code>:</p>
+
+<pre class="brush: js notranslate">// módulo "my-module.js"
+export default function cube(x) {
+  return x * x * x;
+}
+</pre>
+
+<p>Daí em outro script podemos usar:</p>
+
+<pre class="brush: js notranslate">import cube from 'my-module';
+console.log(cube(3)); // 27
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-exports', 'Exports')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Initial definition.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-exports', 'Exports')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade">Compatibilidade</h2>
+
+
+
+<p>{{Compat("javascript.statements.export")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/import", "import")}}</li>
+ <li><a href="https://hacks.mozilla.org/2015/08/es6-in-depth-modules/">ES6 in Depth: Modules</a>, Hacks blog post by Jason Orendorff</li>
+ <li><a href="http://exploringjs.com/es6/ch_modules.html">Axel Rauschmayer's book: "Exploring JS: Modules"</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/for-await...of/index.html b/files/pt-br/web/javascript/reference/statements/for-await...of/index.html
new file mode 100644
index 0000000000..c584b497a8
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/for-await...of/index.html
@@ -0,0 +1,136 @@
+---
+title: for await...of
+slug: Web/JavaScript/Reference/Statements/for-await...of
+translation_of: Web/JavaScript/Reference/Statements/for-await...of
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A <strong>declaração</strong> <strong><code>for await...of</code> </strong>cria um loop que itera sobre objetos iteráveis ​​assíncronos, bem como sobre iteráveis ​​síncronos, incluindo: {{jsxref("String")}}, {{jsxref("Array")}}, <code>Array</code>-como objetos (e.g., {{jsxref("Functions/arguments", "arguments")}} or {{domxref("NodeList")}}), {{jsxref("TypedArray")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, e iteráveis async/sync. Invoca um hook de iteração personalizado com instruções a serem executadas para o valor de cada propriedade do objeto.</p>
+
+
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">for await (<code>variável</code> of <code>iterável</code>) {
+  <em>// declaração
+</em>}
+</pre>
+
+<dl>
+ <dt><code>variável</code></dt>
+ <dd>Em cada iteração, o valor de uma propriedade diferente é atribuído à <em>variável</em>. A <em>variável</em> pode ser declarada como <code>const</code>, <code>let</code> ou <code>var</code>.</dd>
+ <dt><code>iterável</code></dt>
+ <dd>Objeto cujas propriedades iteráveis devem ser iteradas.</dd>
+</dl>
+
+<h3 id="Iterando_sobre_iteráveis_assíncronos">Iterando sobre iteráveis assíncronos</h3>
+
+<p>Você também pode iterar sobre um objeto que explicidamente implementa protocolo iterável assíncrono(<em>async iterable protocol</em>):</p>
+
+<pre class="brush:js">var asyncIterable = {
+  [Symbol.asyncIterator]() {
+    return {
+      i: 0,
+      next() {
+        if (this.i &lt; 3) {
+          return Promise.resolve({ value: this.i++, done: false });
+        }
+
+        return Promise.resolve({ done: true });
+      }
+    };
+  }
+};
+
+(async function() {
+   for await (let num of asyncIterable) {
+     console.log(num);
+   }
+})();
+
+// 0
+// 1
+// 2
+</pre>
+
+<h3 id="Iterando_sobre_generators_assíncronos">Iterando sobre generators assíncronos</h3>
+
+<p>Como os geradores assíncronos implementam o protocolo assíncrono Iterator, eles podem fazer um loop usando <code>for await... of</code></p>
+
+<pre class="brush: js">async function* asyncGenerator() {
+  var i = 0;
+  while (i &lt; 3) {
+    yield i++;
+  }
+}
+
+(async function() {
+  for await (let num of asyncGenerator()) {
+    console.log(num);
+  }
+})();
+// 0
+// 1
+// 2</pre>
+
+<p>Para termos um exemplo mais concreto de iteração sobre um generator assíncrono usando <code>for await... of</code>, considere iterar sobre dados obtidos através de um fecth de uma API. Este exemplo cria primeiro um iterador assíncrono para um stream de dados e depois usa-o para encontrar o tamanho da resposta da API. </p>
+
+<pre class="brush: js">async function* streamAsyncIterator(stream) {
+  const reader = stream.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return;
+      }
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+// Obtém dados do URL e calcula o tamanho da resposta usando o generator assíncrono
+async function getResponseSize(url) {
+  const response = await fetch(url);
+  // Guardará o tamanho do response em bytes.
+  let responseSize = 0;
+  // O for-wait-loop irá iterar de forma assíncrona sobre cada parte do response.
+  for await (const chunk of streamAsyncIterator(response.body)) {
+    // Incrementa o valor do responseSize
+    responseSize += chunk.length;
+  }
+
+  console.log(`Response Size: ${responseSize} bytes`);
+  // output esperado:"Response Size: 1071472"
+  return responseSize;
+}
+getResponseSize('https://jsonplaceholder.typicode.com/photos');</pre>
+
+<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>{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'ECMAScript Language: The for-in, for-of, and for-await-of Statements')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<div class="hidden">A tabela de compatibilidade nesta página é gerada de dados estruturados. Se você quiser contribuir para os dados, por favor acesse <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um <em>pull request</em>.</div>
+
+<p>{{Compat("javascript.statements.for_await_of")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/for...of")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/for...in/index.html b/files/pt-br/web/javascript/reference/statements/for...in/index.html
new file mode 100644
index 0000000000..10d3f34bbb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/for...in/index.html
@@ -0,0 +1,203 @@
+---
+title: for...in
+slug: Web/JavaScript/Reference/Statements/for...in
+tags:
+  - JavaScript
+  - Laço de repetição
+  - Loop
+  - Statement
+  - for...in
+translation_of: Web/JavaScript/Reference/Statements/for...in
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>O laço <strong><code>for...in</code> </strong> interage sobre propriedades enumeradas de um objeto, na ordem original de inserção.  O laço pode ser executado para cada propriedade distinta do objeto.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">for (<var>variavel</var> in objeto) {<em>...</em>
+}</pre>
+
+<dl>
+ <dt><code>variavel</code></dt>
+ <dd>Uma propriedade diferente do objeto é atribuida em cada iteração.</dd>
+ <dt><code>objeto</code></dt>
+ <dd>Objeto com as propriedades enumeradas.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O laço for...in somente iterage sobre propriedades enumeradas. Objetos criados a partir de construtores built-in (arrays e object) herdam propriedades não enumeradas de object.prototype e String.prototype, assim como método {{jsxref("String")}}'s {{jsxref("String.indexOf", "indexOf()")}} ou {{jsxref("Object")}}'s {{jsxref("Object.toString", "toString()")}}. O laço irá iterar sobre todas as propriedades enumeráveis do próprio objeto e somente aquelas enumeráveis herdadas de construtores de objetos prototype.</p>
+
+<h3 id="Propriedades_deletadas_adicionadas_ou_modificadas">Propriedades deletadas, adicionadas ou modificadas</h3>
+
+<p>O laço <code>for...in</code> iterage sobre as propriedades de um objeto em uma ordem arbitrária (veja o {{jsxref("Operators/delete", "delete")}} ). Se uma propriedade é deletada durante a execução do loop, ela se torna indisponível para ser acessada depois. É recomendável não adicionar, remover ou alterar propriedades novas ao objeto durante a execução do laço (durante o loop)</p>
+
+<h3 id="Iteração_em_Arrays_e_for...in">Iteração em Arrays e <code>for...in</code></h3>
+
+<div class="note">
+<p><strong>Note:</strong> <code>for...in</code> não deve ser usado para iteração em uma {{jsxref("Array")}} onde a ordem é importante, visto que ele iterage em uma ordem arbitrária.</p>
+</div>
+
+<p>Indices de arrays somente se tornam propriedades enumeradas com inteiros (integer). Não há garantia de que utilizando o laço for...in os indices de um array serão retornados em uma ordem particular ou irá retornar todas as propriedades enumeráveis. É recomendável utilizar o laço {{jsxref("Statements/for", "for")}} com índices numéricos ou {{jsxref("Array.prototype.forEach()")}} ou ainda {{jsxref("Statements/for...of", "for...of")}} quando iteragir sobre arrays onde a ordem é importante.</p>
+
+<h3 id="Iteração_apenas_sobre_suas_próprias_propriedades">Iteração apenas sobre suas próprias propriedades</h3>
+
+<p>Se você quer considerar somente as propriedades do próprio objeto e não as herdadas via prototype, use {{jsxref("Object.getOwnPropertyNames", "getOwnPropertyNames()")}} ou execute {{jsxref("Object.prototype.hasOwnProperty", "hasOwnProperty()")}}  ou ({{jsxref("Object.prototype.propertyIsEnumerable", "propertyIsEnumerable")}}</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>A função seguinte toma como argumento um objeto. O laço for...in iterage sobre todos as propriedades enumeráveis do objeto e retorna uma string com o nome das propriedades e seus respectivos valores.</p>
+
+<pre class="brush: js">//Objeto
+var obj = {a:1, b:2, c:3};
+
+//Para prop (propriedade) in obj (objeto) faça
+for (var prop in obj) {
+  // ctrl+shift+k (para abrir o console no mozilla firefox)
+  console.log("obj." + prop + " = " + obj[prop]);
+}
+
+//A saída (output) deverá ser:
+// "obj.a = 1"
+// "obj.b = 2"
+// "obj.c = 3"</pre>
+
+<p>A função seguinte ilustra o uso de {{jsxref("Object.prototype.hasOwnProperty", "hasOwnProperty()")}}: as propriedades herdadas não são exibidas.</p>
+
+<pre class="brush: js">var triangle = {a:1, b:2, c:3};
+
+function ColoredTriangle() {
+  this.color = "red";
+}
+
+ColoredTriangle.prototype = triangle;
+
+var obj = new ColoredTriangle();
+
+for (var prop in obj) {
+  if( obj.hasOwnProperty( prop ) ) {
+    console.log("obj." + prop + " = " + obj[prop]);
+  }
+}
+
+// Output:
+// "obj.color = red"
+</pre>
+
+<h2 id="Specificações">Specificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Specificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...in statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-for-in-and-for-of-statements', 'for...in statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.6.4', 'for...in statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-12.6.4', 'for...in statement')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-12.6.3', 'for...in statement')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Browsers">Compatibilidade de Browsers</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Compatibilidade_Initializer_expressions">Compatibilidade: Initializer expressions</h2>
+
+<p>Anterior ao SpiderMonkey 40 {{geckoRelease(40)}}, era possível usar uma expressão inicial com o laço for...in, conforme exemplo que se segue:</p>
+
+<pre class="brush: js example-bad">var obj = {a:1, b:2, c:3};
+for(var i=0 in obj) {
+  console.log(obj[i]);
+}
+// 1
+// 2
+// 3
+</pre>
+
+<p>Este não é o comportamento padrão e atualmente é ignorado a partir da versão 40 e posteriores e seu uso irá exibir o error {{jsxref("SyntaxError")}} ("for-in loop head declarations may not have initializers"). Outras engines como a v8 (Chrome), Chakra (IE/Edge) e JSC (Webkit/Safari) estão estudando o que fazer com esse comportamento.</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/for...of", "for...of")}} - laço similar que iterage sobre os valores das propriedades.</li>
+ <li>{{jsxref("Statements/for_each...in", "for each in")}} -  (deprecated).</li>
+ <li>{{jsxref("Statements/for", "for")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/Iterators_and_Generators">Generator expressions</a> (uses the <code>for...in</code> syntax)</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Enumerability_and_ownership_of_properties">Enumerability and ownership of properties</a></li>
+ <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
+ <li>{{jsxref("Object.prototype.hasOwnProperty()")}}</li>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/for...of/index.html b/files/pt-br/web/javascript/reference/statements/for...of/index.html
new file mode 100644
index 0000000000..fb6d5fb664
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/for...of/index.html
@@ -0,0 +1,298 @@
+---
+title: for...of
+slug: Web/JavaScript/Reference/Statements/for...of
+tags:
+  - ECMAScript 2015
+  - ECMAScript6
+  - JavaScript
+  - Referência(2)
+  - Statement
+translation_of: Web/JavaScript/Reference/Statements/for...of
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>O loop <strong><code>for...of</code></strong> percorre <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/iterable">objetos iterativos</a> (incluindo {{jsxref("Array")}}, {{jsxref("Map")}}, {{jsxref("Set")}}, o objeto <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a> e assim por diante), chamando uma função personalizada com instruções a serem executadas para o valor de cada objeto distinto.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">for (<em>variavel</em> of <em>iteravel</em>) {
+<em>  declaração</em><em>
+</em>}
+</pre>
+
+<dl>
+ <dt><code>variável</code></dt>
+ <dd>A cada iteração, um valor de uma propriedade diferente é atribuido à <em>variável</em>.</dd>
+ <dt><code>iteravel</code></dt>
+ <dd>Objeto cujos atributos serão iterados.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Iterando_sobre_um_jsxref(Array)">Iterando sobre um {{jsxref("Array")}}</h3>
+
+<pre class="brush:js"><code>let iterable = [10, 20, 30];
+
+for (let value of iterable) {
+  console.log(value);
+}
+// 10
+// 20
+// 30</code></pre>
+
+<p>Ao invés de <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a>, você pode usar <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const"><code>const</code></a> se você não for modificar a variável dentro do bloco.</p>
+
+<pre><code>let iterable = [10, 20, 30];
+
+for (const value of iterable) {
+  console.log(value);
+}
+// 10
+// 20
+// 30</code></pre>
+
+<h3 id="Iterando_sobre_uma_jsxref(String)">Iterando sobre uma {{jsxref("String")}}</h3>
+
+<pre><code>let iterable = "boo";
+
+for (let value of iterable) {
+  console.log(value);
+}
+// "b"
+// "o"
+// "o"</code></pre>
+
+<h3 id="Iterando_sobre_uma_jsxref(TypedArray)">Iterando sobre uma {{jsxref("TypedArray")}}</h3>
+
+<pre><code>let iterable = new Uint8Array([0x00, 0xff]);
+
+for (let value of iterable) {
+  console.log(value);
+}
+// 0
+// 255</code></pre>
+
+<h3 id="Iterando_sobre_um_jsxref(Map)">Iterando sobre um {{jsxref("Map")}}</h3>
+
+<pre><code>let iterable = new Map([["a", 1], ["b", 2], ["c", 3]]);
+
+for (let entry of iterable) {
+  console.log(entry);
+}
+// [a, 1]
+// [b, 2]
+// [c, 3]
+
+for (let [key, value] of iterable) {
+  console.log(value);
+}
+// 1
+// 2
+// 3</code></pre>
+
+<h3 id="Iterando_sobre_um_jsxref(Set)">Iterando sobre um {{jsxref("Set")}}</h3>
+
+<pre><code>let iterable = new Set([1, 1, 2, 2, 3, 3]);
+
+for (let value of iterable) {
+  console.log(value);
+}
+// 1
+// 2
+// 3</code></pre>
+
+<h3 id="Iterando_sobre_um_objeto_arguments">Iterando sobre um objeto <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/arguments">arguments</a></h3>
+
+<pre><code>(function() {
+  for (let argument of arguments) {
+    console.log(argument);
+  }
+})(1,2,3);
+
+// 1
+// 2
+// 3</code></pre>
+
+<h3 id="Iterando_sobre_uma_coleção_do_DOM">Iterando sobre uma coleção do DOM</h3>
+
+<p>Iterar sobre uma coleção do DOM como {{domxref("NodeList")}}: o seguinte exemplo adiciona uma classe <code>read</code> aos parágrafos que são descendentes diretos de uma tag <code>article</code>:</p>
+
+<pre><code>// Nota: Isso irá funcionar somente em plataformas que tem
+// suporte ao NodeList.prototype[Symbol.iterator]
+let articleParagraphs = document.querySelectorAll("article &gt; p");
+
+for (let paragraph of articleParagraphs) {
+  paragraph.classList.add("read");
+}</code></pre>
+
+<h3 id="Iterando_sobre_generators">Iterando sobre generators</h3>
+
+<p>Você pode também iterar sobre <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/function*">generators</a>:</p>
+
+<pre><code>function* fibonacci() { // uma função geradora (generator)
+  let [prev, curr] = [1, 1];
+  while (true) {
+    [prev, curr] = [curr, prev + curr];
+    yield curr;
+  }
+}
+
+for (let n of fibonacci()) {
+  console.log(n);
+  // Trunca a sequência em 1000
+  if (n &gt;= 1000) {
+    break;
+  }
+}</code></pre>
+
+<h4 id="Não_reuse_generators">Não reuse generators</h4>
+
+<p>Generators não devem ser re-usados, mesmo se o loop <code>for...of</code> for terminado precocemente, por exemplo através da palavra-chave {{jsxref("Statements/break", "break")}}. Enquanto em um loop ativo, o generator é fechado e tentar iterar novamente sobre ele não produz (yield) nenhum resultado adicional. O Firefox ainda não implementou este comportamento (o generator pode ser reutilizado, violando o padrão do ES2015 (<a href="https://www.ecma-international.org/ecma-262/6.0/#sec-13.7.5.13">13.7.5.13, step 5m</a>), mas isso irá mudar uma vez que o {{Bug(1147371)}} for resolvido.</p>
+
+<pre><code>var gen = (function *(){
+  yield 1;
+  yield 2;
+  yield 3;
+})();
+for (let o of gen) {
+  console.log(o);
+  break;  // Closes iterator
+}
+
+// O generator não deve ser reutilizado, o código a seguir não
+// faz sentido!
+for (let o of gen) {
+  console.log(o); // Nunca será chamado.
+}</code></pre>
+
+<h3 id="Iterando_sobre_outros_objetos_iteráveis">Iterando sobre outros objetos iteráveis</h3>
+
+<p>Você pode também iterar sobre um objeto que implementa explicitamente um protocolo <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Iteration_protocols#iterable">iterável</a> protocol:</p>
+
+<pre><code>var iterable = {
+  [Symbol.iterator]() {
+    return {
+      i: 0,
+      next() {
+        if (this.i &lt; 3) {
+          return { value: this.i++, done: false };
+        }
+        return { value: undefined, done: true };
+      }
+    };
+  }
+};
+
+for (var value of iterable) {
+  console.log(value);
+}
+// 0
+// 1
+// 2</code></pre>
+
+<h3 id="Diferença_entre_for...of_e_for...in">Diferença entre <code>for...of</code> e <code>for...in</code></h3>
+
+<p>O loop <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...in">for...in</a></code> irá iterar sobre todas as propriedades enumeráveis de um objeto.</p>
+
+<p>A sintaxe do <code>for...of</code> é específica para <strong>coleções</strong>, ao invés de todos os objetos. Ela irá iterar desta maneira sobre os elementos de qualquer coleção que tiver uma propriedade <code>[Symbol.iterator]</code>.</p>
+
+<p>O exemplo a seguir mostra a diferença entre um loop <code>for...of</code> e um loop <code>for...in</code>.</p>
+
+<pre><code>Object.prototype.objCustom = function () {};
+Array.prototype.arrCustom = function () {};
+
+let iterable = [3, 5, 7];
+iterable.foo = "hello";
+
+for (let i in iterable) {
+  console.log(i); // escreve 0, 1, 2, "foo", "arrCustom", "objCustom"
+}
+
+for (let i of iterable) {
+  console.log(i); // escreve 3, 5, 7
+}</code></pre>
+
+<h3 id="Especificações">Especificações</h3>
+
+<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-for-in-and-for-of-statements', 'for...of statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>Definition Inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-for-in-and-for-of-statements', 'for...of statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_navegadores">Compatibilidade dos navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Edge</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Funções básicas</td>
+   <td>{{CompatChrome(38)}} [1]</td>
+   <td>{{CompatGeckoDesktop("13")}} [2]</td>
+   <td>12</td>
+   <td>25</td>
+   <td>7.1</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Funções básicas</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatChrome(38)}} [1]</td>
+   <td>{{CompatGeckoMobile("13")}} [2]</td>
+   <td>{{CompatUnknown}}</td>
+   <td>{{CompatUnknown}}</td>
+   <td>8</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<p>[1] Do Chrome 29 ao Chrome 37 essa funcionalidade estava disponível através de uma configuração. Em chrome://flags/#enable-javascript-harmony, habilite a função “Enable Experimental JavaScript”.</p>
+
+<p>[2] Do Gecko 17 (Firefox 17 / Thunderbird 17 / SeaMonkey 2.14) ao Gecko 26 (Firefox 26 / Thunderbird 26 / SeaMonkey 2.23 / Firefox OS 1.2) a propriedade i<code>terator</code> era usada (<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=907077">bug 907077</a>), e do Gecko 27 ao Gecko 35 o placeholder <code>"@@iterator"</code> era usado. No Gecko 36 (Firefox 36 / Thunderbird 36 / SeaMonkey 2.33), o <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Symbol">símbolo</a> <code>@@iterator</code> foi implementada (<a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918828">bug 918828</a>).</p>
+
+<h2 id="Consulte_também">Consulte também</h2>
+
+<ul>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for_each...in">for each...in</a> - uma declaração similar, mas que itera entre os valores dos atributos de um objeto, ao invés dos seus nomes (obsoleto).</li>
+ <li>{{jsxref("Array.prototype.forEach()")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/for/index.html b/files/pt-br/web/javascript/reference/statements/for/index.html
new file mode 100644
index 0000000000..981f11051a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/for/index.html
@@ -0,0 +1,191 @@
+---
+title: for
+slug: Web/JavaScript/Reference/Statements/for
+translation_of: Web/JavaScript/Reference/Statements/for
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A instrução <code>for</code><strong> </strong>cria um loop que consiste em três expressões opcionais, dentro de parênteses e separadas por ponto e vírgula, seguidas por uma declaração ou uma sequência de declarações executadas em sequência.</p>
+
+<p>A fonte desse exemplo interativo está armazenada em um repositório do GitHub. Se você gostaria de contribuir com os projetos de exemplos interativos, por favor clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a>  e nos envie um pull request (requisição para puxar).</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">for ([<em>inicialização</em>]; [<em>condição</em>]; [<em>expressão final</em>])
+  <em> declaração</em>
+</pre>
+
+<dl>
+ <dt><code>inicialização</code></dt>
+ <dd>Uma expressão (incluindo expressões de atribuição) ou declarações variáveis. Geralmente usada para iniciar o contador de variáveis. Esta expressão pode, opcionalmente, declarar novas variáveis com a palavra chave <code>var</code>. Essas variáveis não são locais no loop, isto é, elas estão no mesmo escopo que o loop <code>for</code><strong> </strong>está. Variáveis declaradas com let são locais para a declaração.</dd>
+ <dd>O resultado desta expressão é descartado.</dd>
+ <dt><code>condição</code></dt>
+ <dd>Uma expressão para ser avaliada antes de cada iteração do loop. Se esta expressão for avaliada para true, <code>declaração</code> será executado. Este teste da condição é opcional. Se omitido, a condição sempre será avaliada como verdadeira. Se a expressão for avaliada como falsa, a execução irá para a primeira expressão após a construção loop <code>for</code>.</dd>
+ <dt><code>expressão final</code></dt>
+ <dd>Uma expressão que será validada no final de cada iteração de loop. Isso ocorre antes da próxima avaliação da condição. Geralmente usado para atualizar ou incrementar a variável do contador.</dd>
+ <dt><code>declaração</code></dt>
+ <dd>Uma declaração que é executada enquanto a condição for verdadeira. Para executar múltiplas condições dentro do loop, use uma instrução de bloco <code>({...})</code> para agrupar essas condições. Para não executar declarações dentro do loop, use uma instrução vazia <code>(;)</code>.</dd>
+</dl>
+
+<h2 id="Exemplos_de_uso">Exemplos de uso</h2>
+
+<h3 id="Usando_for">Usando <code>for</code></h3>
+
+<p>A declaração <code>for</code> começa declarando a variável <code>i</code> e inicializando-a como <code>0</code>. Ela verifica se <code>i</code> é menor que nove, executa as duas instruções subsequentes e incrementa 1 a variável <code>i</code> após cada passagem pelo loop.</p>
+
+<pre class="brush: js notranslate">for (var i = 0; i &lt; 9; i++) {
+   console.log(i);
+   // more statements
+}
+</pre>
+
+<h3 id="Expressões_for_opcionais">Expressões <code>for</code> opcionais</h3>
+
+<p>Todas as três expressões na condição do loop <code>for</code> são opcionais.</p>
+
+<p>Por exemplo, no bloco de <em>inicialização</em>, não é necessário inicializar variáveis:</p>
+
+<pre class="brush: js notranslate">var i = 0;
+for (; i &lt; 9; i++) {
+    console.log(i);
+    // more statements
+}
+</pre>
+
+<p>Assim como ocorre no bloco de <em>inicialização</em>, a <em>condição</em> também é opcional. Se você está omitindo essa expressão, você deve certificar-se de quebrar o loop no corpo para não criar um loop infinito.</p>
+
+<pre class="brush: js notranslate">for (var i = 0;; i++) {
+   console.log(i);
+   if (i &gt; 3) break;
+   // more statements
+}</pre>
+
+<p>Você também pode omitir todos os três blocos. Novamente, certifique-se de usar uma instrução <code>break</code> no final do loop e também modificar (incrementar) uma variável, para que a condição do <code>break</code> seja verdadeira em algum momento.</p>
+
+<pre class="brush: js notranslate">var i = 0;
+
+for (;;) {
+  if (i &gt; 3) break;
+  console.log(i);
+  i++;
+}
+</pre>
+
+<h3 id="Usando_for_sem_uma_declaração">Usando <code>for</code> sem uma declaração </h3>
+
+<p>O ciclo <code>for</code> a seguir calcula a posição de deslocamento de um nó na seção [expressão final] e, portanto, não requer o uso de uma declaração ou de um bloco de declaração, e no seu lugar é usado um ponto-vírgula - <code>;</code>.</p>
+
+<pre class="brush: js notranslate">function showOffsetPos (sId) {
+  var nLeft = 0, nTop = 0;
+
+  for (var oItNode = document.getElementById(sId); // inicialização
+       oItNode; // condition
+       nLeft += oItNode.offsetLeft, nTop += oItNode.offsetTop, oItNode = oItNode.offsetParent) // expressão final
+       /* empty statement */ ;
+
+  console.log("Offset position of \"" + sId + "\" element:\n left: " + nLeft + "px;\n top: " + nTop + "px;");
+}
+
+// Exemplo de call:
+
+showOffsetPos("content");
+
+// Resultado:
+// "Offset position of "content" element:
+// left: 0px;
+// top: 153px;"</pre>
+
+<div class="note"><strong>Nota:</strong> Nesse caso, quando você não usa a seção de declaração, <strong>o</strong><strong> ponto-e-vírgula é colocada imediatamente após a declaração do ciclo</strong>.</div>
+
+<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>ECMAScript 1st Edition.</td>
+   <td>Padrão</td>
+   <td>
+    <p>Definição inicial.</p>
+   </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.6.3', 'for statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-for-statement', 'for statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_em_Browsers">Compatibilidade em Browsers</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/break", "break")}}</li>
+ <li>{{jsxref("Statements/continue", "continue")}}</li>
+ <li>{{jsxref("Statements/empty", "empty")}}</li>
+ <li>{{jsxref("Statements/while", "while")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/do...while"><code>do...while</code></a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a></li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/for_each...in/index.html b/files/pt-br/web/javascript/reference/statements/for_each...in/index.html
new file mode 100644
index 0000000000..8206aa9f5a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/for_each...in/index.html
@@ -0,0 +1,126 @@
+---
+title: for each...in
+slug: Web/JavaScript/Reference/Statements/for_each...in
+tags:
+  - Declaração
+  - Deprecado
+  - Deprecated
+  - JavaScript
+  - Obsoleto
+translation_of: Archive/Web/JavaScript/for_each...in
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<div class="warning">
+<p>A declaração <code>for each...in</code> está obsoleta como parte do padrão ECMA-357 (<a href="/en-US/docs/Archive/Web/E4X" title="/en-US/docs/E4X">E4X</a>). O suporte E4X foi removido, mas o for each...in não será desativado e removido por questões de compatibilidade que precisam ser consideradas.  Ao invés disso, procure utilizar <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of" title="/en-US/docs/JavaScript/Reference/Statements/for...of">for...of</a>. (Por favor, referir-se a {{ bug("791343")}}.)</p>
+
+<p><strong>O Firefox agora alerta sobre o uso de <code>for each...in e não funciona mais no Firefox Nighly.</code> Por favor veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Errors/For-each-in_loops_are_deprecated">Alerta: Loops for-each-in do JavaScript 1.6 estão obsoletos</a> para ajuda com a migração.</strong></p>
+</div>
+
+<p>A <code><strong>declaração for each...in</strong></code> repete uma variável especifica sobre todos os valores das propriedades do objeto. Para cada propriedade distinta, uma declaração específica é executada.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox"><code>for each (<em>variable</em> in <em>object</em>) {
+  <em>statement</em>
+}</code></pre>
+
+<dl>
+ <dt><code>variável</code></dt>
+ <dd>Variável que itera sobre o valor da propriedade, opcionalmente declarado com a palavra-chave <code>var</code>. Essa variável é local à função, não ao loop.</dd>
+</dl>
+
+<dl>
+ <dt><code>objeto</code></dt>
+ <dd>Objeto ao qual as propriedades são iteradas.</dd>
+</dl>
+
+<dl>
+ <dt><font face="Consolas, Liberation Mono, Courier, monospace">declaração</font></dt>
+ <dd>Uma declaração a ser executada para cada propriedade. Para executar múltiplas declaração dentro do loop, utilize um <a href="/en-US/docs/Web/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">bloco</a> de declaração (<code>{ ... }</code>) para agrupar estas declarações.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Algumas propriedades internas não são iterada. Isso inclui todos os métodos internos dos objetos, ex. o método <code>String</code>'s <code>indexOf</code> . No entanto, todas propriedades definidas pelo usuários são iteradas.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_for_each...in">Usando <code>for each...in</code></h3>
+
+<p><strong>Atenção:</strong> Nunca utiliza um loop assim com arrays. Apenas utilize em objetos. Veja <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a> para mais detalhes.</p>
+
+<p>O seguinte código itera sobre as propriedades do objeto, calculando sua soma:</p>
+
+<pre class="brush:js">var sum = 0;
+var obj = {prop1: 5, prop2: 13, prop3: 8};
+
+for each (var item in obj) {
+  sum += item;
+}
+
+console.log(sum); // escreve no log "26", que é 5+13+8</pre>
+
+<h2 id="Especifições">Especifições</h2>
+
+<p>Não faz parte da atual especificação ECMA-262. Implementado no JavaScript 1.6 e está obsoleto.</p>
+
+<h2 id="Compatibilidade_de_Browsers">Compatibilidade de Browsers</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoDesktop("1.8")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatGeckoMobile("1.0")}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+   <td>{{CompatNo}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in" title="JavaScript/Reference/Statements/for...in">for...in</a></code> - uma declaração similar que itera sobre a propriedade <em>names</em>.</li>
+ <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of" title="/en-US/docs/JavaScript/Reference/Statements/for...of">for...of</a></code> - uma declaração similar que itera sobre os <em>valores</em> da propriedade mas pode ser utilizado para iterar tipos, então para para objetos genéricos.</li>
+ <li><code><a href="/en-US/docs/JavaScript/Reference/Statements/for" title="JavaScript/Reference/Statements/for">for</a></code></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/funcoes_assincronas/index.html b/files/pt-br/web/javascript/reference/statements/funcoes_assincronas/index.html
new file mode 100644
index 0000000000..808f0b0306
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/funcoes_assincronas/index.html
@@ -0,0 +1,149 @@
+---
+title: Funções assíncronas
+slug: Web/JavaScript/Reference/Statements/funcoes_assincronas
+tags:
+  - Função
+  - assíncrono
+translation_of: Web/JavaScript/Reference/Statements/async_function
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A declaração <code><strong>async function</strong></code> define uma <em>função assíncrona</em>, que retorna um objeto {{jsxref("Global_Objects/AsyncFunction","AsyncFunction")}}.</p>
+
+<div class="noinclude">
+<p>Você também pode definir funções assíncronas usando uma {{jsxref("Operators/async_function", "expressão async function")}}.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">async function <em>nome</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
+   <em>instruções</em>
+}
+</pre>
+
+<dl>
+ <dt><code>nome</code></dt>
+ <dd>O nome da função.</dd>
+</dl>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>O nome de um parâmetro a ser passado para a função.</dd>
+</dl>
+
+<dl>
+ <dt><code>instruções</code></dt>
+ <dd>As instruções que compõem o corpo da função.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Quando uma função assíncrona é chamada, ela retorna uma {{jsxref("Promise")}}. Quando a função assíncrona retorna um valor, a <code>Promise</code> será resolvida com o valor retornado. Quando a função assíncrona lança uma exceção ou algum valor, a <code>Promise</code> será rejeitada com o valor lançado.</p>
+
+<p>Uma função assíncrona pode conter uma expressão {{jsxref("Operators/await", "await")}}, que pausa a execução da função assíncrona e espera pela resolução da <code>Promise </code>passada, e depois retoma a execução da função assíncrona e retorna o valor resolvido.</p>
+
+<div class="note">
+<p>A proposta das funções <code>async/await</code> é de simplificar o uso de forma síncrona das <code>Promises</code> e executar alguns procedimentos em um grupo de <code>Promises</code>. Assim como <code>Promises</code> são similares a <code>callbacks</code> estruturados, funções <code>async/await</code> são similares à junção de <code>generators</code> com <code>P</code><code>romises</code>.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_simples">Exemplo simples</h3>
+
+<pre class="brush: js">function resolverDepoisDe2Segundos(x) {
+  return new Promise(resolve =&gt; {
+    setTimeout(() =&gt; {
+      resolve(x);
+    }, 2000);
+  });
+}
+
+async function adicionar1(x) {
+  var a = resolverDepoisDe2Segundos(20);
+  var b = resolverDepoisDe2Segundos(30);
+  return x + await a + await b;
+}
+
+adicionar1(10).then(v =&gt; {
+  console.log(v);  // exibe 60 depois de 2 segundos.
+});
+
+async function adicionar2(x) {
+  var a = await resolverDepoisDe2Segundos(20);
+  var b = await resolverDepoisDe2Segundos(30);
+  return x + a + b;
+}
+
+adicionar2(10).then(v =&gt; {
+  console.log(v);  // exibe 60 depois de 4 segundos.
+});
+</pre>
+
+<h3 id="Reescrevendo_uma_cadeia_de_Promise_com_uma_função_async">Reescrevendo uma cadeia de <code>Promise</code> com uma função <code>async</code></h3>
+
+<p>Uma API que retorna uma {{jsxref("Promise")}} vai resultar em uma cadeia de <code>Promises</code> e separa a função em várias partes. Considere o seguinte código:</p>
+
+<pre class="brush: js">function pegarDadosProcessados(url) {
+  return baixarDados(url) // retorna uma Promise
+    .catch(e =&gt; {
+      return baixarDadosReservas(url) // retorna uma Promise
+    })
+    .then(v =&gt; {
+      return processarDadosNoWorker(v); // retorna uma Promise
+    });
+}
+</pre>
+
+<p>pode ser escrita em uma única função <code>async</code> desta forma:</p>
+
+<pre class="brush: js">async function pegarDadosProcessados(url) {
+  let v;
+  try {
+    v = await baixarDados(url);
+  } catch(e) {
+    v = await baixarDadosReservas(url);
+  }
+  return processarDadosNoWorker(v);
+}
+</pre>
+
+<p>Note que no exemplo acima não tem a instrução <code>await</code> na instrução do <code>return</code>, porque o valor retornado de uma função <code>async é </code>implícitamente passado por um {{jsxref("Promise.resolve")}}.</p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-async-function-definitions', 'async function')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definição inicial no ES2017.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browser">Compatibilidade de browser</h2>
+
+<div>{{Compat("javascript.statements.async_function")}}</div>
+
+<div id="compat-desktop"></div>
+
+<h3 id="Notas_específicas_do_Firefox">Notas específicas do Firefox</h3>
+
+<ul>
+ <li>A função <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Expression_closures">expression closure syntax</a> não é permitida com funções assíncronas e irão lançar a exceção <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/SyntaxError">SyntaxError</a> a partir do Firefox 55.</li>
+</ul>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/async_function">async_function</a></li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction">AsyncFunction</a></li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Operators/await">await</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/function/index.html b/files/pt-br/web/javascript/reference/statements/function/index.html
new file mode 100644
index 0000000000..77915f919b
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/function/index.html
@@ -0,0 +1,176 @@
+---
+title: Declaração de função
+slug: Web/JavaScript/Reference/Statements/function
+translation_of: Web/JavaScript/Reference/Statements/function
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A <strong>declaração function </strong>define uma função com os especificados parâmetros.<strong> </strong></p>
+
+<p>Você pode também definir funções usando o construtor {{jsxref("Function")}}  e uma {{jsxref("Operators/function", "function expression")}}.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">function <em>name</em>([<em>param</em>,[, <em>param</em>,[..., <em>param</em>]]]) {
+   [<em>statements</em>]
+}
+</pre>
+
+<dl>
+ <dt><code>name</code></dt>
+ <dd>O nome da função.</dd>
+</dl>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>O nome de um argumento a ser passado para a função. Uma função pode ter atè 255 argumentos.</dd>
+</dl>
+
+<dl>
+ <dt><code>statements</code></dt>
+ <dd>As instruções que compõem o corpo da função.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Uma função criada com uma declaração function é um objeto <code>Function</code> e tem todas as propriedades, métodos e comportamentos dos objetos <code>Function</code>. Veja {{jsxref("Function")}} para informações detalhadas sobre as funções.</p>
+
+<p>Uma função pode também ser criada usando uma expressão (veja {{jsxref("Operators/function", "function expression")}}).</p>
+
+<p>Por padrão, funções retornam <code>undefined</code>. Para retornar qualquer outro valor, a função precisa ter uma instrução {{jsxref("Statements/return", "return")}} que especifica o valor para retorno.</p>
+
+<h3 id="Criando_funções_condicionalmente.">Criando funções condicionalmente.</h3>
+
+<p>Funções podem ser condicionalmente declaradas, isso é, uma instrução de função pode ser aninhada dentro de uma instrução <code>if</code>. A maioria dos navegadores que não sejam Mozilla ir tratar essas declarações condicionais como uma incondicional <span class="short_text" id="result_box" lang="pt"><span class="hps">e criará a função se a condição for true ou não, veja </span></span><a href="http://kangax.github.io/nfe/#function-statements">esse artigo</a> para uma visão geral. Portanto, ela não pode ser usada para <span class="short_text" id="result_box" lang="pt"><span class="hps">criação</span> de <span class="hps">expressões de função</span> <span class="hps">condicional</span><span>.</span></span></p>
+
+<h3 id="Declarações_de_funções_hoisting">Declarações de funções hoisting</h3>
+
+<p>Declarações de funções em JavaScript <span id="result_box" lang="pt"><span class="hps">são</span> hoisted</span> à<span lang="pt"><span class="hps"> definição da função</span><span>.</span></span> Você pode usar uma função antes de tê-la declarado:</p>
+
+<pre class="brush: js">hoisted(); // logs "foo"
+
+function hoisted() {
+  console.log("foo");
+}
+</pre>
+
+<p>Note que {{jsxref("Operators/function", "function expressions")}} não são hoisted:</p>
+
+<pre class="brush: js">notHoisted(); // TypeError: notHoisted is not a function
+
+var notHoisted = function() {
+   console.log("bar");
+};
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_funções">Usando funções</h3>
+
+<p>O seguinte código declara uma função que retorna a quantidade total das vendas, quando dados os números de unidades vendidas dos produtos a, b e c.</p>
+
+<pre class="brush: js">function calc_sales(units_a, units_b, units_c) {
+   return units_a * 79 + units_b * 129 + units_c * 699;
+}
+</pre>
+
+<h2 id="Especificações"><span class="short_text" id="result_box" lang="pt"><span class="hps">Especificações</span></span></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>{{SpecName('ESDraft', '#sec-function-definitions', 'Function definitions')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-function-definitions', 'Function definitions')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-13', 'Function definition')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-13', 'Function definition')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-13', 'Function definition')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td><span class="short_text" id="result_box" lang="pt"><span class="hps">Definição</span> <span class="hps">inicial.</span> <span class="hps">Implementado em</span> <span class="hps">JavaScript</span> <span class="hps">1.0.</span></span></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_com_navegadores">Compatibilidade com navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li>
+ <li>{{jsxref("Function")}}</li>
+ <li>{{jsxref("Operators/function", "function expression")}}</li>
+ <li>{{jsxref("Statements/function*", "function* statement")}}</li>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("Functions/Arrow_functions", "Arrow functions")}}</li>
+ <li>{{jsxref("GeneratorFunction")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/function_star_/index.html b/files/pt-br/web/javascript/reference/statements/function_star_/index.html
new file mode 100644
index 0000000000..d80b9f8e3d
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/function_star_/index.html
@@ -0,0 +1,203 @@
+---
+title: function*
+slug: Web/JavaScript/Reference/Statements/function*
+tags:
+  - ECMAScript6
+  - Function
+  - Iterator
+  - JavaScript
+  - Statement
+translation_of: Web/JavaScript/Reference/Statements/function*
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A declaração <code><strong>function*</strong></code> (palavra chave <code>function</code> seguida de um asterisco) define uma <em>função geradora</em> (<em>generator function</em>), que retorna um objeto {{jsxref("Global_Objects/Generator","Generator")}}.</p>
+
+<p>{{EmbedInteractiveExample("pages/js/statement-functionasterisk.html")}}</p>
+
+<p>Você também pode definir funções geradoras usando o construtor {{jsxref("GeneratorFunction")}} ou a sintaxe da expressão de uma função. </p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">function* <em>name</em>([<em>param</em>[, <em>param</em>[, ... <em>param</em>]]]) {
+   <em>statements</em>
+}</pre>
+
+<dl>
+ <dt><code>name</code></dt>
+ <dd>O nome da função.</dd>
+</dl>
+
+<dl>
+ <dt><code>param</code></dt>
+ <dd>O nome do argumento que será passado á função. Uma função pode ter até 255 argumentos.</dd>
+</dl>
+
+<dl>
+ <dt><code>statements</code></dt>
+ <dd>As instruções que formam o corpo da função.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Geradores são funções cuja execução pode ser interrompida e posteriormente reconduzida. Seus contextos (de associações de variáveis) ficarão salvos entre cada recondução.</p>
+
+<p>Geradores em JavaScript -- especialmente quando combinados com <em>Promises </em>-- são uma ferramenta muito poderosa para programação assíncrona, por mitigarem -- se não eliminarem -- problemas com callbacks, como o <a href="http://callbackhell.com/">Callback Hell</a> e <a href="https://frontendmasters.com/courses/rethinking-async-js/callback-problems-inversion-of-control/">Inversão de Controle</a>. Funções <code><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/async_function">async</a></code> são fundamentadas nisso.</p>
+
+<p>Chamar uma função geradora não executa seu conteúdo imediatamente; ao invés disso um objeto <em><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">iterator</a></em> é retornado. Quando o método <code>next()</code> do objeto <em>iterator</em> é chamado, o conteúdo da função do gerador é executado até a primeira expressão {{jsxref("Operators/yield", "yield")}}, que especifica o valor a ser devolvido do <em>iterator </em>ou com {{jsxref("Operators/yield*", "yield*")}} que delega para outra função geradora. O método <code style="font-style: normal; line-height: 1.5;">next()</code><span style="line-height: 1.5;"> retorna um objeto com uma propriedade </span><code><span style="font-family: consolas,monaco,andale mono,monospace; line-height: 1.5;">value</span></code><span style="line-height: 1.5;"> contendo o valor retornado e a propriedade <em>boolean</em>: </span><code><span style="font-family: consolas,monaco,andale mono,monospace; line-height: 1.5;">done</span></code><span style="line-height: 1.5;"> indicando se o gerador produziu seu último valor. Chamar o método <code>next()</code> com um argumento resumirá a execução da função geradora, substituindo a expressão <code>yield</code> onde a execução foi pausada com o argumento de <code>next()</code>.</span></p>
+
+<p><span style="line-height: 1.5;">Uma expressão <code>return</code> em um gerador, quando executada, fará com que o gerador termine (isto é, a propriedade <code>done</code> do objeto retornado será atribuído com o valor <code>true</code>). Se um valor foi retornado, este será usado como propriedade <code>value</code> do objeto retornado pelo gerador. Semelhantemente a uma expressão <code>return</code>, um erro lançado dentro do gerador o terminará -- a não ser que tratado no corpo do gerador. Quando um gerador estiver terminado, chamadas <code>next</code> subsequentes não executarão nenhum código do gerador, retornarão simplesmente um objeto da seguinte forma: <code>{value: undefined, done: true}</code>.</span></p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Exemplo_simples">Exemplo simples</h3>
+
+<pre class="brush: js notranslate">function* idMaker(){
+    var index = 0;
+    while(true)
+        yield index++;
+}
+
+var gen = idMaker();
+
+console.log(gen.next().value); // 0
+console.log(gen.next().value); // 1
+console.log(gen.next().value); // 2
+<code>console.log(gen.next().value); // 3</code>
+// ...</pre>
+
+<h3 id="Exemplo_com_yield*">Exemplo com yield*</h3>
+
+<pre class="brush: js notranslate">function* outroGerador(i) {
+  yield i + 1;
+  yield i + 2;
+  yield i + 3;
+}
+
+function* gerador(i){
+  yield i;
+  yield* outroGerador(i);
+  yield i + 10;
+}
+
+var gen = gerador(10);
+
+console.log(gen.next().value); // 10
+console.log(gen.next().value); // 11
+console.log(gen.next().value); // 12
+console.log(gen.next().value); // 13
+console.log(gen.next().value); // 20
+</pre>
+
+<h3 id="Passando_argumentos_em_geradores">Passando argumentos em geradores</h3>
+
+<pre class="notranslate"><code>function* logGenerator() {
+  console.log(0);
+  console.log(1, yield);
+  console.log(2, yield);
+  console.log(3, yield);
+}
+
+var gen = logGenerator();
+
+// a primeira chamada next é executada desde o início da função
+// até a primeira declaração yield
+gen.next();             // 0
+gen.next('pretzel');    // 1 pretzel
+gen.next('california'); // 2 california
+gen.next('mayonnaise'); // 3 mayonnaise</code></pre>
+
+<h3 id="Declaração_de_retono_em_um_gerador">Declaração de retono em um gerador</h3>
+
+<pre class="notranslate"><code>function* yieldAndReturn() {
+  yield "Y";
+  return "R";
+  yield "unreachable";
+}
+
+var gen = yieldAndReturn()
+console.log(gen.next()); // { value: "Y", done: false }
+console.log(gen.next()); // { value: "R", done: true }
+console.log(gen.next()); // { value: undefined, done: true }</code></pre>
+
+<h3 id="Geradores_não_possuem_construtor">Geradores não possuem construtor</h3>
+
+<pre class="notranslate"><code>function* f() {}
+var obj = new f; // lança o TypeError: f não é construtor</code></pre>
+
+<h3 id="Gerador_definido_em_uma_expressão">Gerador definido em uma expressão</h3>
+
+<pre class="notranslate"><code>const foo = function* () {
+  yield 10;
+  yield 20;
+};
+
+const bar = foo();
+console.log(bar.next()); // {value: 10, done: false}</code></pre>
+
+<h2 id="Specifications" name="Specifications">Especificações</h2>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Status</th>
+   <th scope="col">Comentário</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td>{{SpecName('ES2015', '#sec-generator-function-definitions', 'function*')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES2016', '#sec-generator-function-definitions', 'function*')}}</td>
+   <td>{{Spec2('ES2016')}}</td>
+   <td>Mudou para que <em>generators </em>não tenham a armadilha de [[Construct]] e irão lançar um erro, quando usados com <code>new</code>.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-generator-function-definitions', 'function*')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Browser_compatibility" name="Browser_compatibility">Compatibilidade entre Navegadores</h2>
+
+<div></div>
+
+<div id="compat-mobile">{{Compat("javascript.statements.generator_function")}}</div>
+
+<h2 id="Observações_específicas_Firefox">Observações específicas Firefox</h2>
+
+<h4 id="Generators_e_iterators_no_Firefox_em_versões_anteriores_a_26">Generators e iterators no Firefox em versões anteriores a 26</h4>
+
+<p>Versões mais antigas do Firefox implementam uma versão antiga da proposta de <em>generators</em>. Na versão mais antiga, <em>generators </em>foram intruídos a usarem a palavra chave <code>function</code>(sem um asterísco) dentre outras diferenças.</p>
+
+<h4 id="O_retorno_do_objeto_IteratorResult_ao_invés_de_um_throw">O retorno do objeto <code>IteratorResult</code> ao invés de um throw</h4>
+
+<p>Iniciando com Gecko 29 {{geckoRelease(29)}}, o <em>generator </em>finalizado não lança mais um {{jsxref("TypeError")}} "generator has already finished". Ao invés disso, ele retorna um objeto <code>IteratorResult</code>, como por exemplo <code>{ value: undefined, done: true }</code> ({{bug(958951)}}).</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Operators/function*", "function* expression")}}</li>
+ <li>{{jsxref("GeneratorFunction")}} object</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Guide/The_Iterator_protocol">The Iterator protocol</a></li>
+ <li>{{jsxref("Operators/yield", "yield")}}</li>
+ <li>{{jsxref("Operators/yield*", "yield*")}}</li>
+ <li>{{jsxref("Function")}} object</li>
+ <li>{{jsxref("Statements/function", "function declaration")}}</li>
+ <li>{{jsxref("Operators/function", "function expression")}}</li>
+ <li>{{jsxref("Functions_and_function_scope", "Functions and function scope")}}</li>
+ <li>Outras fontes na web:
+  <ul>
+   <li><a href="http://facebook.github.io/regenerator/">Regenerator</a> um ES6 generator que compila para ES5</li>
+   <li><a href="http://www.youtube.com/watch?v=qbKWsbJ76-s">Forbes Lindesay: Promises and Generators: control flow utopia -- JSConf EU 2013</a></li>
+   <li><a href="https://www.youtube.com/watch?v=ZrgEZykBHVo&amp;list=PLuoyIZT5fPlG44bPq50Wgh0INxykdrYX7&amp;index=1">Hemanth.HM: The New gen of *gen(){}</a></li>
+   <li><a href="http://taskjs.org/">Task.js</a></li>
+  </ul>
+ </li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/if...else/index.html b/files/pt-br/web/javascript/reference/statements/if...else/index.html
new file mode 100644
index 0000000000..e61389f5bb
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/if...else/index.html
@@ -0,0 +1,211 @@
+---
+title: if...else
+slug: Web/JavaScript/Reference/Statements/if...else
+tags:
+  - Instrução
+  - JavaScript
+  - condicional
+  - if else
+  - se então
+translation_of: Web/JavaScript/Reference/Statements/if...else
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A condicional<strong> if </strong> é uma estrutura condicional que executa a afirmação, dentro do bloco, se determinada condição for verdadeira. Se for falsa, executa as afirmações dentro de <strong>else</strong>.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">if (<em>condição</em>) <em>afirmação1 [</em>else <em>afirmação2</em>]</pre>
+
+<dl>
+ <dt><code>condição</code></dt>
+ <dd>Uma <a href="/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Expressions">expressão</a> (premissa) que pode ser avaliada como verdadeira (true) ou falsa (false), veja lógica de programação para entender melhor.</dd>
+</dl>
+
+<dl>
+ <dt><code>condição1</code></dt>
+ <dd>Condicional que será executada caso a condição em <em>if</em> seja verdadeira (true). Pode ser qualquer instrução, incluindo mais condicionais <em>if</em> aninhadas à instrução. Para executar multiplas instruções, faça um agrupamento com uma instrução em <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block" title="en/JavaScript/Reference/Statements/block">bloco</a> ({ ... }). Para não executar nenhuma instrução, utilize uma instrução vazia (<a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/Empty">empty</a>).</dd>
+</dl>
+
+<dl>
+ <dt><code>condição2</code></dt>
+ <dd>Condicional que será executada caso a condição em <em>if</em> seja avaliada como falsa (false) e a condição <em>else</em> exista. Pode ser qualquer instrução, incluindo instruões em bloco e mais condicionais <em>if</em> aninhadas. </dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Múltiplas condicionais<em> if ... else</em> podem ser aninhados quando necessário. Observe que não existe elseif (em uma palavra). O correto é a instrução com espaços (else if), conforme abaixo:</p>
+
+<pre class="eval">if (<em>condição1</em>)
+   <em>instrução1</em>
+else if (<em>condição2</em>)
+   <em>instrução2</em>
+else if (<em>condição3</em>)
+   <em>instrução3</em>
+...
+else
+   <em>instruçãoN</em>
+</pre>
+
+<p>Para ver seu funcionamento, abaixo está a instrução como deveria ser caso identada corretamente.</p>
+
+<pre class="eval">if (<em>condição1</em>)
+   <em>instrução1</em>
+else
+   if (<em>condição2</em>)
+      <em>instrução2</em>
+   else
+      if (<em>condição3</em>)
+...
+</pre>
+
+<p>Para executar multiplas instruções dentro de uma condição, utilize um bloco (<code>{ ... }</code>) . Em geral, é sempre uma boa prática utilizar instruções dentro de blocos, especialmente em códigos que envolvam condicionais <em>if </em>aninhadas:</p>
+
+<pre class="eval">if (<em>condição</em>) {
+   <em>instrução1</em>
+} else {
+   <em>instrução2</em>
+}
+</pre>
+
+<p>Não confunda os valores boolean primitivos <code>true</code> e <code>false</code> com os valores true e false do objeto <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean" title="en/JavaScript/Reference/Global_Objects/Boolean">Boolean</a>. Qualquer valor que não for <code>undefined</code>, <code>null</code>, <code>0</code>, <code>NaN</code>, ou uma string vazia (<code>""</code>), e qualquer objeto, incluíndo um objeto Boolean cujo valor é false, é avaliado como true quando passado por uma condicional. Por exemplo:</p>
+
+<pre class="brush: js">var b = new Boolean(false);
+if (b) // essa condição é avaliada como true
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_if...else">Usando <code>if...else</code></h3>
+
+<pre class="brush: js">if (cipher_char === from_char) {
+   result = result + to_char;
+   x++;
+} else {
+   result = result + clear_char;
+}
+</pre>
+
+<h3 id="Usando_else_if">Usando <code>else if</code></h3>
+
+<p>Perceba que não existe sintaxe de <code>elseif</code> em JavaScript. Entretanto, você pode escrevê-la com um espaço entre o if e o  else.</p>
+
+<pre class="brush: js">if (x &gt; 5) {
+
+} else if (x &gt; 50) {
+
+} else {
+
+}</pre>
+
+<h3 id="Atribuições_junto_de_expressões_condicionais">Atribuições junto de expressões condicionais</h3>
+
+<p>É recomendado não utilizar atribuições simples junto de uma expressão condicional, visto que atribuições podem ser confundidas com igualdade ao olhar o código. Por exemplo, não use o código abaixo:</p>
+
+<pre class="brush: js">if (x = y) {
+   /* faça a coisa certa */
+}
+</pre>
+
+<p>Caso você precise utilizar uma atribuição em uma expressão condicional, uma prática comum é inserir parênteses adicionais em volta da atribuição. Por exemplo:</p>
+
+<pre class="brush: js">if ((x = y)) {
+   /* faça a coisa certa */
+}
+</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('ESDraft', '#sec-if-statement', 'if statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-if-statement', 'if statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.5', 'if statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-12.5', 'if statement')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-12.5', 'if statement')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição Inicial</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_Navegadores">Compatibilidade entre Navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte Básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/block", "block")}}</li>
+ <li>{{jsxref("Statements/switch", "switch")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/import.meta/index.html b/files/pt-br/web/javascript/reference/statements/import.meta/index.html
new file mode 100644
index 0000000000..9e6a31a523
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/import.meta/index.html
@@ -0,0 +1,93 @@
+---
+title: import.meta
+slug: Web/JavaScript/Reference/Statements/import.meta
+translation_of: Web/JavaScript/Reference/Statements/import.meta
+---
+<div>{{JSSidebar("Statements")}}</div>
+
+<p><code><font face="Arial, x-locale-body, sans-serif"><span style="background-color: #ffffff;">O objeto mostra o </span></font><strong>import.meta</strong></code> mostra o contexto específico metadata para um módulo JavaScript. Ele contém informações sobre o módulo, como a sua URL.</p>
+
+<h2 id="Sintaxe">Sintaxe </h2>
+
+<pre class="syntaxbox notranslate">import.meta</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>A sintaxe consiste na palavra chave {{JSxRef("Statements/import","import")}}, um ponto, e o identificador <code>meta</code>. Normalmente no lado esquerdo do ponto é o objeto na qual a propriedade de acesso é realizada is, mas aqui <code>import</code> não é exatamente um objeto.</p>
+
+<p>O objeto<code>import.meta</code> foi criado no implementação ECMAScript,com um protótipo {{JSxRef("null")}}. O objeto é extensível, e suas propriedades são grávaveis, configuráveis, e enumeráveis.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_import.meta">Usando import.meta</h3>
+
+<p>Dado o modulo <code>my-module.js</code></p>
+
+<pre class="brush: html notranslate">&lt;script type="module" src="my-module.js"&gt;&lt;/script&gt;
+</pre>
+
+<p>Você pode acessar essa meta informação sobre o modulo usando o objeto <code>import.meta.</code></p>
+
+<pre class="brush: js; notranslate">console.log(import.meta); // { url: "file:///home/user/my-module.js" }</pre>
+
+<p>Irá returnar um objeto com propriedade URL indicando a base URL do módulo. Isso vai ser o URL da qual o script obteve, por scripts external, ou a base do documento URL contendo documento, para scripts inline.</p>
+
+<p>Note que isso irá incluir parâmetros query e/ou cerquilha (i.e., seguindo o <code>?</code> ou <code>#</code>).</p>
+
+<p>Por exemplo, seguindo esse HTML:</p>
+
+<pre class="brush: html notranslate">&lt;script type="module"&gt;
+import './index.mjs?someURLInfo=5';
+&lt;/script&gt;</pre>
+
+<p>O arquivo JavaScript a seguir vai registrar o parâmetro `<code>someURLInfo</code>:</p>
+
+<pre class="brush: js notranslate">// index.mjs
+new URL(import.meta.url).searchParams.get('someURLInfo'); // 5</pre>
+
+<p>O mesmo se aplica quando um arquivo importa outro:</p>
+
+<pre class="brush: js notranslate">// index.mjs
+import './index2.mjs?someURLInfo=5';
+
+// index2.mjs
+new URL(import.meta.url).searchParams.get('someURLInfo'); // 5</pre>
+
+<p>Note que enquanto o Node.js vai passar nos parâmetros query (ou na cerquilha) como no exemplo passsado, a partir do Node 14.1.0, a URL com parâmetro query vai dar erro quando carregar no formulário  <code>node --experimental-modules index.mjs?someURLInfo=5</code> (é tratado como um arquivo ao invés de uma  URL nesse contexto).</p>
+
+<p>Nesse arquivo específico, o argumento passado pode ser complementar para ser usado na ampla aplicação <code>location.href</code> (com strings query ou cerquilha adicionada depois do caminho de arquivo HTML) (ou por Node.js, através do <code>process.argv</code>).</p>
+
+<h2 id="Especifícações">Especifícações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especifícação</th>
+  </tr>
+  <tr>
+   <td><code><a href="https://tc39.es/proposal-import-meta/#prod-ImportMeta">import.meta</a></code> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName("HTML WHATWG", "webappapis.html#hostgetimportmetaproperties", "import.meta")}}</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compartibilidade_no_Browser"> Compartibilidade no Browser </h2>
+
+<div class="hidden">A tabela de compartibilidade nessa página é gerado por um dado estruturado.Se você gostaria de contribuir para esse dado, por favor, acesso <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</div>
+
+<p>{{Compat("javascript.statements.import_meta")}}</p>
+
+<h3 id="Progressão_de_implementação">Progressão de implementação</h3>
+
+<p>A tabela seguinte fornece um status de implementação diária para essa feature, porque ela ainda não alcançou a estabilidade cross-browser. Os dados são gerados por relevantes testes de feature no <a href="https://github.com/tc39/test262">Test262</a>, o padrão de teste para JavaScript, em build noturno, ou no ultimo lançamento de cada engine browser de JavaScript.</p>
+
+<div>{{EmbedTest262ReportResultsTable("import.meta")}}</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{JSxRef("Statements/import", "import")}}</li>
+ <li>{{JSxRef("Statements/export", "export")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/import/index.html b/files/pt-br/web/javascript/reference/statements/import/index.html
new file mode 100644
index 0000000000..a87ed0f4bf
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/import/index.html
@@ -0,0 +1,286 @@
+---
+title: import
+slug: Web/JavaScript/Reference/Statements/import
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Modules
+  - Reference
+  - Statement
+  - dynamic import
+  - import
+translation_of: Web/JavaScript/Reference/Statements/import
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<div>
+<p>A declaração estática <strong><code>import</code></strong> é usada para importar vínculos que são exportados por um outro módulo. Os módulos importados estão em {{JSxRef("Strict_mode","strict mode")}},  declarado como tal ou não. A declaração <code>import</code> não pode ser usada em scripts embutidos, a menos que tal script tenha um <code>type="module"</code>.</p>
+
+<p>Há também uma função dinâmica<strong> </strong><code><strong>import()</strong></code>, que não requer scripts de <code>type="module"</code>.</p>
+
+<p>A compatibilidade com versões anteriores pode ser garantida usando o atributo <code>nomodule </code>na tag de script.</p>
+
+<p>A importação dinâmica é útil em situações em que você deseja carregar um módulo condicionalmente ou sob demanda. A forma estática é preferível para carregar dependências iniciais e pode se beneficiar mais prontamente de ferramentas de análise estática e <a href="/en-US/docs/Glossary/Tree_shaking">tree shaking</a>.</p>
+</div>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre>import <em>defaultExport</em> from "<em>module-name</em>";
+import * as <em>name</em> from "<em>module-name</em>";
+import { <em>export </em>} from "<em>module-name</em>";
+import { <em>export</em> as <em>alias </em>} from "<em>module-name</em>";
+import { <em>export1 , export2</em> } from "<em>module-name</em>";
+import { <em>foo , bar</em> } from "<em>module-name/path/to/specific/un-exported/file</em>";
+import { <em>export1 , export2</em> as <em>alias2</em> , <em>[...]</em> } from "<em>module-name</em>";
+import <em>defaultExport</em>, { <em>export</em> [ , <em>[...]</em> ] } from "<em>module-name</em>";
+import <em>defaultExport</em>, * as <em>name</em> from "<em>module-name</em>";
+import "<em>module-name</em>"; var <em>promise</em> = import("module-name"); // This is a stage 3 proposal.</pre>
+
+<dl>
+ <dt><code>defaultExport</code></dt>
+ <dd>Nome que de referência para a exportação padrão do módulo.</dd>
+ <dt><code>module-name</code></dt>
+ <dd>O módulo para importar. Geralmente, esse é um nome de caminho relativo ou absoluto para o arquivo <code>.js</code> contendo esse módulo. Certos empacotadores podem permitir ou exigir o uso da extensão; verifique seu ambiente. Apenas aspas simples e aspas duplas são permitidas.</dd>
+ <dt><code>name</code></dt>
+ <dd>Nome do objeto do módulo que será usado como um tipo de espaço de nomes ao se referir às importações.</dd>
+ <dt><code>export, exportN</code></dt>
+ <dd>Nome das exportações a serem importadas.</dd>
+ <dt><code>alias, aliasN</code></dt>
+ <dd>Nomes que se referem às importações nomeadas.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>O parâmetro name é o nome do "objeto módulo", que será usado como um tipo de namespace para se referir às exportações. Os parâmetros de exportação especificam exportações nomeadas individuais, enquanto a importação * como sintaxe de nome importa todos eles. Abaixo estão alguns exemplos para esclarecer a sintaxe.</p>
+
+<h3 id="Importar_o_conteúdo_de_todo_um_módulo">Importar o conteúdo de todo um módulo</h3>
+
+<p>Isso insere <code>myModule</code> no escopo atual, contendo todas as exportações do módulo no arquivo localizado em <code>/modules/my-module.js</code>.</p>
+
+<pre><code>import * as myModule from '/modules/my-module.js';</code></pre>
+
+<p>Aqui, acessar as exportações significa usar o nome do módulo ("myModule" neste caso) como um namespace. Por exemplo, se o módulo importado acima incluir um export <code>doAllTheAmazingThings()</code>, você o chamaria assim:</p>
+
+<pre><code>myModule.doAllTheAmazingThings();</code></pre>
+
+<h3 id="Importar_uma_única_exportação_de_um_módulo">Importar uma única exportação de um módulo</h3>
+
+<p>Dado um objeto ou valor chamado <code>myExport</code>que foi exportado do módulo <code>my-module</code>  implicitamente (porque o módulo inteiro é exportado) ou explicitamente (usando a instrução {{JSxRef("Statements/export", "export")}} statement), isso insere  <code>myExport</code> no escopo atual.</p>
+
+<pre><code>import {myExport} from '</code>/modules/my-module.js';</pre>
+
+<h3 id="Importar_várias_exportações_do_módulo">Importar várias exportações do módulo</h3>
+
+<p>Isso inclui tanto <code>foo</code> como <code>bar</code>  no escopo atual.</p>
+
+<h3 id="Importar_uma_exportação_com_um_alias_mais_conveniente">Importar uma exportação com um alias mais conveniente</h3>
+
+<p>Você pode renomear uma exportação ao importá-la. Por exemplo, isso insere <code>shortName</code> no escopo atual.</p>
+
+<p> </p>
+
+<pre><code>import {reallyReallyLongModuleExportName as shortName}
+</code>  from '/modules/my-module.js';</pre>
+
+<h3 id="Renomear_várias_exportações_durante_a_importação">Renomear várias exportações durante a importação</h3>
+
+<p>Importe várias exportações de um módulo com aliases convenientes.</p>
+
+<p> </p>
+
+<pre><code>import {
+  reallyReallyLongModuleExportName as shortName,
+  anotherLongModuleName as short
+</code>} from '/modules/my-module.js';</pre>
+
+<h3 id="Importar_um_módulo_apenas_para_seus_efeitos_colaterais">Importar um módulo apenas para seus efeitos colaterais</h3>
+
+<p>Importe um módulo inteiro somente para efeitos colaterais, sem importar nada. Isso executa o código global do módulo, mas na verdade não importa nenhum valor.</p>
+
+<p> </p>
+
+<pre>import '/modules/my-module.js';</pre>
+
+<h3 id="Importando_Padrões">Importando Padrões</h3>
+
+<p>É possível ter um padrão {{JSxRef ("Declarações / exportação", "exportação")}} (seja um objeto, uma função, uma classe etc.). A declaração de importação pode então ser usada para importar esses padrões.</p>
+
+<p> </p>
+
+<p>A versão mais simples importa diretamente o padrão:</p>
+
+<p> </p>
+
+<pre><code>import myDefault from '/modules/my-module.</code>js';</pre>
+
+<p> </p>
+
+<p>Também é possível usar a sintaxe padrão com as vistas acima (importações de namespace ou importações nomeadas). Em tais casos, a importação padrão terá que ser declarada primeiro. Por exemplo:</p>
+
+<p> </p>
+
+<pre><code>import myDefault, * as myModule from '/modules/my-module.js';
+// myModule used as a namespac</code>e</pre>
+
+<p>Ou</p>
+
+<p> </p>
+
+<pre><code>import myDefault, {foo, bar} from '/modules/my-module.js';
+</code>// specific, named imports</pre>
+
+<p> </p>
+
+<h3 id="Importações_Dinâmicas">Importações Dinâmicas</h3>
+
+<p> </p>
+
+<p>A palavra-chave <code>import</code> pode ser chamada como uma função para importar dinamicamente um módulo. Quando usado dessa maneira, retorna uma promessa.</p>
+
+<p> </p>
+
+<pre><code>import('/modules/my-module.js')
+  .then((module) =&gt; {
+    // Do something with the module.
+ </code> });</pre>
+
+<p> </p>
+
+<p>Este formulário também suporta a palavra-chave await.</p>
+
+<p> </p>
+
+<pre><code>let module = await import('/modules/my-module.js');</code>
+</pre>
+
+<p> </p>
+
+<p> </p>
+
+<p> </p>
+
+<p> </p>
+
+<p> </p>
+
+<p> </p>
+
+<p> </p>
+
+<p> </p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Padrão_Import">Padrão Import</h3>
+
+<p>O código abaixo mostra como importar um módulo secundário para auxiliar no processamento de uma requisição AJAX que retorna um JSON.</p>
+
+<p> </p>
+
+<h4 id="O_Módulo_file.js">O Módulo: file.js</h4>
+
+<p> </p>
+
+<pre><code>function getJSON(url, callback) {
+  let xhr = new XMLHttpRequest();
+  xhr.onload = function () {
+    callback(this.responseText)
+  };
+  xhr.open('GET', url, true);
+  xhr.send();
+}
+
+export function getUsefulContents(url, callback) {
+  getJSON(url, data =&gt; callback(JSON.parse(data)));
+}</code></pre>
+
+<p><strong>O programa principal: main.js</strong></p>
+
+<p> </p>
+
+<pre class="brush: js">im<code>port { getUsefulContents } from '/modules/file.js';
+
+getUsefulContents('http://www.example.com',
+    data =&gt; { doSomethingUseful(data); });</code></pre>
+
+<h3 id="Dynamic_Import">Dynamic Import</h3>
+
+<p>Este exemplo mostra como carregar a funcionalidade em uma página com base em uma ação do usuário, nesse caso, um clique no botão e, em seguida, chamar uma função dentro desse módulo. Esta não é a única maneira de implementar essa funcionalidade. A função <code>import()</code> também é compatível com <code>await</code>.</p>
+
+<p> </p>
+
+<pre class="brush: js"><code>const main = document.querySelector("main");
+for (const link of document.querySelectorAll("nav &gt; a")) {
+  link.addEventListener("click", e =&gt; {
+    e.preventDefault();
+
+    import('/modules/my-module.js')
+      .then(module =&gt; {
+        module.loadPageInto(main);
+      })
+      .catch(err =&gt; {
+        main.textContent = err.message;
+      });
+  });
+}</code></pre>
+
+<p> </p>
+
+<p> </p>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Estado</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td><a href="https://github.com/tc39/proposal-dynamic-import/#import">"function-like" dynamic <code>import()</code> proposal</a></td>
+   <td>Stage 3</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName("ESDraft", "#sec-imports", "Imports")}}</td>
+   <td>{{Spec2("ESDraft")}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName("ES2018", "#sec-imports", "Imports")}}</td>
+   <td>{{Spec2("ES2018")}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName("ES2017", "#sec-imports", "Imports")}}</td>
+   <td>{{Spec2("ES2017")}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName("ES2016", "#sec-imports", "Imports")}}</td>
+   <td>{{Spec2("ES2016")}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName("ES2015", "#sec-imports", "Imports")}}</td>
+   <td>{{Spec2("ES2015")}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_entre_navegadores">Compatibilidade entre navegadores</h2>
+
+<p>{{Compat("javascript.statements.import")}}</p>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{JSxRef("Statements/export", "export")}}</li>
+ <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/import.meta"><code>import.meta</code></a></li>
+ <li><a href="https://blogs.windows.com/msedgedev/2016/05/17/es6-modules-and-beyond/">Previewing ES6 Modules and more from ES2015, ES2016 and beyond</a></li>
+ <li><a href="https://hacks.mozilla.org/2015/08/es6-in-depth-modules/">ES6 in Depth: Modules</a>, Hacks blog post by Jason Orendorff</li>
+ <li><a href="https://hacks.mozilla.org/2018/03/es-modules-a-cartoon-deep-dive/">ES modules: A cartoon deep-dive</a>, Hacks blog post by Lin Clark</li>
+ <li><a href="http://exploringjs.com/es6/ch_modules.html">Axel Rauschmayer's book: "Exploring JS: Modules"</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/index.html b/files/pt-br/web/javascript/reference/statements/index.html
new file mode 100644
index 0000000000..42b9a2850e
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/index.html
@@ -0,0 +1,128 @@
+---
+title: Instruções e declarações
+slug: Web/JavaScript/Reference/Statements
+tags:
+  - NeedsTranslation
+  - TopicStub
+translation_of: Web/JavaScript/Reference/Statements
+---
+<div>{{jsSidebar("Instruções")}}</div>
+
+<p>Aplicações em JavaScript são realizadas através de instruções com uma sintaxe apropriada. Uma única instrução pode abranger multiplas linhas. Multiplas instruções podem estar contidas em uma única linha se cada instrução estiver separada por ponto e vírgula ( ; ).</p>
+
+<h2 id="Instruções_e_declarações_por_categoria">Instruções e declarações por categoria</h2>
+
+<p>Para visualizar em ordem alfabética use a barra de rolagem à esquerda.</p>
+
+<h3 id="Control_flow">Control flow</h3>
+
+<dl>
+ <dt>{{jsxref("Statements/block", "Block")}}</dt>
+ <dd>Uma instrução de bloqueio é usada para um grupo de zero ou mais instruções. O bloqueio é delimitado por um par de chaves.</dd>
+ <dt>{{jsxref("Statements/break", "break")}}</dt>
+ <dd>Termina o atual loop, troca, ou nomeia instruções e transfere o controle do programa para a próxima instrução após a que foi terminada agora.</dd>
+ <dt>{{jsxref("Statements/continue", "continue")}}</dt>
+ <dd>Termina a execução das instruções na atual iteração do atual loop, e continua a execução do loop com a seguinte iteração.</dd>
+ <dt>{{jsxref("Statements/Empty", "Empty")}}</dt>
+ <dd>Uma instrução vazia é usada para gerar uma "não-instrução", ainda que o JavaScrpit espere uma.</dd>
+ <dt>{{jsxref("Statements/if...else", "if...else")}}</dt>
+ <dd>Executa uma instrução se a condição especificada é verdadeira. Se a condição é falsa, outra instrução pode ser executada.</dd>
+ <dt>{{jsxref("Statements/switch", "switch")}}</dt>
+ <dd>Retorna uma expressão, combinando o valor da expressão a condição do caso, e executa a condição associada a este caso.</dd>
+ <dt>{{jsxref("Statements/throw", "throw")}}</dt>
+ <dd>Aplica uma exceção definida pelo usuário.</dd>
+ <dt>{{jsxref("Statements/try...catch", "try...catch")}}</dt>
+ <dd>Marca um bloco de instruções para tentar, e especifica a resposta, uma exceção deve ser retornada.</dd>
+</dl>
+
+<h3 id="Declarações">Declarações</h3>
+
+<dl>
+ <dt>{{jsxref("Statements/var", "var")}}</dt>
+ <dd>Declara uma variável, opcionalmente inicializando com um valor.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Statements/let", "let")}}</dt>
+ <dd>Declara acesso ao local da variável, opcionalmente inicializando com um valor.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Statements/const", "const")}}</dt>
+ <dd>Declara uma constante de apenas leitura.</dd>
+</dl>
+
+<h3 id="Funções_e_classes">Funções e classes</h3>
+
+<dl>
+ <dt>{{jsxref("Statements/function", "function")}}</dt>
+ <dd>Declara uma função com os parâmetros especificos.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Statements/function*", "function*")}}</dt>
+ <dd>Gera funções habilitando iteradores de escrita mais facilmente.</dd>
+ <dt>{{jsxref("Statements/return", "return")}}</dt>
+ <dd>Especifica o valor a ser retornado por uma função.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Statements/class", "class")}}</dt>
+ <dd>Declara uma classe.</dd>
+</dl>
+
+<h3 id="Iterações">Iterações</h3>
+
+<dl>
+ <dt>{{jsxref("Statements/do...while", "do...while")}}</dt>
+ <dd>Cria um loop que executa uma especifica instrução até que a condição de teste seja falsa. A condição é retornada depois da execução da instrução, resultando na instrução especificada executando ao menos uma vez.</dd>
+ <dt>{{jsxref("Statements/for", "for")}}</dt>
+ <dd>Cria um loop que consiste em três opções de expressões, entre parenteses e separado por ponto e vírgula, seguido pela instrução executada no loop.</dd>
+ <dt>{{deprecated_inline}} {{non-standard_inline()}} {{jsxref("Statements/for_each...in", "for each...in")}}</dt>
+ <dd>Itera uma variável especificada sobre todos os valores das propriedades do objeto. Para cada propriedade distinta, uma instrução especificada é executada.</dd>
+ <dt>{{jsxref("Statements/for...in", "for...in")}}</dt>
+ <dd>Itera através de enumeráveis propriedades de um objeto, em ordem arbitrária. Para cada propriedade distinta, instruções podem ser executadas.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Statements/for...of", "for...of")}}</dt>
+ <dd>Itera através de objetos iteráveis (incluindo <a href="https://developer.mozilla.org/en-US/docs/Core_JavaScript_1.5_Reference/Global_Objects/Array" title="Array">arrays</a>, array-like objects, <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Guide/Iterators_and_Generators" title="Iterators and generators">iterators and generators</a>), invocando uma iteração personalizada com  instruções para serem executadas pelo valor de cada propriedade.</dd>
+ <dt>{{jsxref("Statements/while", "while")}}</dt>
+ <dd>Cria um loop que executa uma especifica instrução enquanto o teste da condição for positivo. A condição é retornada antes de executar a instrução.</dd>
+</dl>
+
+<h3 id="Outros">Outros</h3>
+
+<dl>
+ <dt>{{jsxref("Statements/debugger", "debugger")}}</dt>
+ <dd>Invoca qualquer funcionalidade de depuração disponível. Se não há funcionabilidade disponível, a instrução não tem efeito.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Statements/export", "export")}}</dt>
+ <dd>Usado para exportar funções que os deixa disponível para importação em módulos externos, outros scripts.</dd>
+ <dt>{{experimental_inline}} {{jsxref("Statements/import", "import")}}</dt>
+ <dd>Usado para importar funções exportadas de um módulo externo, outro script.</dd>
+ <dt>{{jsxref("Statements/label", "label")}}</dt>
+ <dd>Fornece uma instrução com um identificador que pode ser referido usando <code>break</code> ou <code>continue</code> instruções.</dd>
+</dl>
+
+<dl>
+ <dt>{{deprecated_inline}} {{jsxref("Statements/with", "with")}}</dt>
+ <dd>Extende o alcance de uma instrução.</dd>
+</dl>
+
+<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-12', 'Statements')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-ecmascript-language-statements-and-declarations', 'ECMAScript Language: Statements and Declarations')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td>New: function*, let, for...of, yield, class</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators">Operators</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/label/index.html b/files/pt-br/web/javascript/reference/statements/label/index.html
new file mode 100644
index 0000000000..b1f9aeb5af
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/label/index.html
@@ -0,0 +1,101 @@
+---
+title: label (Etiqueta)
+slug: Web/JavaScript/Reference/Statements/label
+tags:
+  - JavaScript
+  - Statement
+translation_of: Web/JavaScript/Reference/Statements/label
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>Provém uma declaração com um indentificador o qual pode ser referido posteriormente utilizando-se os comandos <em>break</em> ou <em>continue</em>.</p>
+
+<p>Por exemplo, você pode usar um <em>label</em> para identificar um laço e então com um comando de <em>break</em> ou <em>continue</em> indicar se este deve ser interrompido ou então continuar sua execução.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox"><em>label</em> :
+   declaração
+</pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<dl>
+ <dt><code>label</code></dt>
+ <dd>Qualquer idenfiticador JavaScript válido que não é uma palavra reservada.</dd>
+ <dt><code>declaração</code></dt>
+ <dd>Uma declaração qualquer. <em>break</em> pode ser utilizado com qualquer declaração entiquetada (com <em>label</em>) , assim como o <em>continue</em> também pode.</dd>
+</dl>
+
+<div class="warning">
+<h3 id="Avoid_using_labels" name="Avoid_using_labels">Evite usar labels</h3>
+
+<p>Labels não são comunmente utilizados em JavaScript já que estes fazem com que programas fiquei mais difíceis de ler e entender. Sempre que possível evite utilizar labels e, dependendo dos casos, prefira <a href="https://developer.mozilla.org/pt-BR/docs/JavaScript/Reference/Statements/function">chamar funções</a> ou <a href="https://developer.mozilla.org/pt-BR/docs/JavaScript/Reference/Statements/throw">lançar um erro</a>.</p>
+</div>
+
+<h2 id="Examples" name="Examples">Examplos</h2>
+
+<h3 id="Example_1" name="Example_1"><code>Exemplo com continue</code></h3>
+
+<pre class="brush: js">var i, j;
+
+loop1:
+for (i = 0; i &lt; 3; i++) {      //O primeiro 'for' é etiquetado com "loop1"
+   loop2:
+   for (j = 0; j &lt; 3; j++) {   //O segundo é etiquetado com "loop2"
+      if (i == 1 &amp;&amp; j == 1) {
+         continue loop1;
+      } else {
+         console.log("i = " + i + ", j = " + j);
+      }
+   }
+}
+
+// Sua saída é:
+//   "i = 0, j = 0"
+//   "i = 0, j = 1"
+//   "i = 0, j = 2"
+//   "i = 1, j = 0"
+//   "i = 2, j = 0"
+//   "i = 2, j = 1"
+//   "i = 2, j = 2"
+// Note como pula-se "i = 1, j = 1" e "i = 1, j = 2"
+</pre>
+
+<h3 id="Example_2" name="Example_2">Exemplo 2 <code>(continue)</code></h3>
+
+<p>Dado uma lista de itens e outra de testes, este exemplo conta o número de ítens que passam em todos os testes.</p>
+
+<pre class="brush: js">var itemsPassed = 0;
+var i, j;
+
+top:
+for (i = 0; i &lt; items.length; i++){
+  for (j = 0; j &lt; tests.length; j++)
+    if (!tests[j].pass(items[i]))
+      continue top;
+  itemsPassed++;
+}</pre>
+
+<h3 id="Example_3" name="Example_3">Exemplo 3 <code>(break)</code></h3>
+
+<p>Dado uma lista de ítens e uma lista de testes, neste exemplo determina-se se todos os ítens passam em todos os testes.</p>
+
+<pre class="brush: js">var allPass = true;
+var i, j;
+
+top:
+for (i = 0; items.length; i++)
+  for (j = 0; j &lt; tests.length; i++)
+    if (!tests[j].pass(items[i])){
+      allPass = false;
+      break top;
+    }
+</pre>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/JavaScript/Reference/Statements/break" title="JavaScript/Reference/Statements/break">break</a></li>
+ <li><a href="/en-US/docs/JavaScript/Reference/Statements/continue" title="JavaScript/Reference/Statements/continue">continue</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/let/index.html b/files/pt-br/web/javascript/reference/statements/let/index.html
new file mode 100644
index 0000000000..757754a08a
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/let/index.html
@@ -0,0 +1,140 @@
+---
+title: let
+slug: Web/JavaScript/Reference/Statements/let
+tags:
+  - ECMAScript 2015
+  - JavaScript
+  - Variable declaration
+  - Variables
+translation_of: Web/JavaScript/Reference/Statements/let
+---
+<div>
+<div>{{jsSidebar("Statements")}}</div>
+</div>
+
+<p>Declara uma variável local no escopo do bloco atual, opcionalmente iniciando-a com um valor.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<p>Definição <code>let</code>:</p>
+
+<pre class="syntaxbox">let var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]];</pre>
+
+<p>Expressão <code>let</code>:</p>
+
+<pre class="syntaxbox">let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) expression;</pre>
+
+<p>Instrução <code>let</code>:</p>
+
+<pre class="syntaxbox">let (var1 [= value1] [, var2 [= value2]] [, ..., varN [= valueN]]) statement;</pre>
+
+<h3 id="Parameters" name="Parameters">Parâmetros</h3>
+
+<table class="standard-table">
+ <thead>
+  <tr>
+   <th scope="col">Parameter</th>
+   <th scope="col">Description</th>
+  </tr>
+ </thead>
+ <tbody>
+  <tr>
+   <td><code>var1</code>, <code>var2</code>, …, <code>varN</code></td>
+   <td>Nome da variável. Pode ser qualquer identificador válido.</td>
+  </tr>
+  <tr>
+   <td><code>value1</code>, <code>value2</code>, …, <code>valueN</code></td>
+   <td>Valor inicial da variável. Pode ser qualquer expressão válida.</td>
+  </tr>
+  <tr>
+   <td><code>expression</code></td>
+   <td>Qualquer <a href="/en-US/docs/JavaScript/Guide/Expressions_and_Operators#Expressions" title="JavaScript/Guide/Expressions and Operators#Expressions">expressão</a> válida.</td>
+  </tr>
+  <tr>
+   <td><code>statement</code></td>
+   <td>Qualquer <a href="https://developer.mozilla.org/en-US/docs/JavaScript/Reference/Statements" title="JavaScript/Reference/Statements">instrução</a> válida.</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p><code>let</code> permite que você declare variáveis limitando seu escopo no bloco, instrução, ou em uma expressão na qual ela é usada. Isso é inverso da keyword <a href="/en-US/docs/JavaScript/Reference/Statements/var" title="JavaScript/Reference/Statements/var"><code>var</code></a>, que define uma variável globalmente ou no escopo inteiro de uma função, independentemente do escopo de bloco.</p>
+
+<div class="note">
+<p><span style="color: #333333;"><strong>Nota do tradutor:</strong></span> o trecho acima: "independentemente do escopo de bloco", na verdade, significa dizer que variáveis declaradas dentro de blocos internos da função, por exemplo, são vinculadas no escopo da função, não no bloco no qual elas são declaradas. Se isso parece confuso - e realmente é -, apenas entenda que, ao contrário do que se poderia supor, em Javascript blocos não possuem escopo como em outras linguagens, somente funções têm! Isso quer dizer que mesmo uma váriavel definida com a keyword <code>var</code> dentro de um bloco de instrução <code>if</code>, será visível no resto inteiro da função.</p>
+</div>
+
+
+
+<h2 id="Block_scoping" name="Block_scoping">Escopo de bloco</h2>
+
+<p>Variáveis declaradas com <code>let</code> são "içadas" para começo do bloco em que elas são definidas (isso é conhecido também pelo termo, hoisting).</p>
+
+<p>Redeclaração de uma mesma variável num mesmo escopo de bloco causa um <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/TypeError" title="TypeError">TypeError</a></code>.</p>
+
+<pre class="brush: js">if (x) {
+  let foo;
+  let foo; // Emite um TypeError.
+}</pre>
+
+<p>No entanto, corpos de funções não possuem essa limitação!</p>
+
+<pre class="brush: js">function do_something() {
+  let foo;
+  let foo; // Isso funciona.
+}</pre>
+
+<div class="warning"><strong>Atenção:</strong> Os rascunhos do ECMAScript 6 (desde abril de 2012) tornam este comportamento ilegal. Isso significa, provavelmente, que as futuras versões do JavaScript levantarão um <code><a href="/en-US/docs/JavaScript/Reference/Global_Objects/TypeError" title="TypeError">TypeError</a></code>. Então, se você faz isso, deveria evitar essa prática!</div>
+
+<p>Você pode encontrar erros em instruções <a href="/en-US/docs/JavaScript/Reference/Statements/switch" title="switch"><code>switch</code></a> porque existe apenas um bloco subjacente.</p>
+
+<pre class="brush: js">switch (x) {
+  case 0:
+    let foo;
+    break;
+
+  case 1:
+    let foo; // TypeError para a redeclaração.
+    break;
+}</pre>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<p>Uma <em>expressão let</em> limita o escopo de uma variável declarada somente para aquela expressão.</p>
+
+<pre class="brush: js">var a = 5;
+let(a = 6) alert(a); // 6
+alert(a); // 5</pre>
+
+<p>Usada dentro de um bloco, <em>let</em> limita os escopo das variáveis para aquele bloco. Observe a diferença entre <em>var </em>em que o escopo é definido dentro da função onde é declarada</p>
+
+<pre class="brush: js">var a = 5;
+var b = 10;
+
+if (a === 5) {
+  let a = 4; // O escopo é dentro do bloco if
+  var b = 1; // O escopo é dentro da função
+
+  console.log(a);  // 4
+  console.log(b);  // 1
+}
+
+console.log(a); // 5
+console.log(b); // 1</pre>
+
+<p>É possível usar a keyword <em>let</em> para vincular variáveis ​​localmente no escopo de loops em vez de usar uma variável global (definida usando <em>var</em>) para isso.</p>
+
+<pre class="brush: js">for (let i = 0; i&lt;10; i++) {
+  alert(i); // 1, 2, 3, 4 ... 9
+}
+
+alert(i); // i não está definida</pre>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/JavaScript/Reference/Statements/var" title="JavaScript/Reference/Statements/var"><code>var</code></a></li>
+ <li><a href="/en-US/docs/JavaScript/Reference/Statements/const" title="JavaScript/Reference/Statements/const"><code>const</code></a></li>
+ <li><a href="/pt-BR/docs/JavaScript/New_in_JavaScript/1.7#Block_scope_with_let_(Merge_into_let_Statement)" title="JavaScript/New in JavaScript/1.7#Block scope with let (Merge into let Statement)">Novidades do JavaScript 1.7</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/return/index.html b/files/pt-br/web/javascript/reference/statements/return/index.html
new file mode 100644
index 0000000000..e7c92426fe
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/return/index.html
@@ -0,0 +1,197 @@
+---
+title: return
+slug: Web/JavaScript/Reference/Statements/return
+tags:
+  - Declaração
+  - JavaScript
+  - Statement
+translation_of: Web/JavaScript/Reference/Statements/return
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A <strong>declaração <code>return</code></strong> finaliza a execução de uma função e especifica os valores que devem ser retonados para onde a função foi chamada.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">return [[expression]]; </pre>
+
+<dl>
+ <dt><code>expression</code></dt>
+ <dd>A expressão cujo valor será retornado. Se omitido, <code>undefined</code> é retornado.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Quando uma declaração <code>return</code> é usada em um corpo de função, a execução dessa função é parada. Se especificado, um dado valor é retornado à quem chamou a função. Se a expressão for omitida, <code>undefined</code> será retornado. Todas as declarações return a seguir param a execução da função:</p>
+
+<pre class="brush: js">return;
+return true;
+return false;
+return x;
+return x + y / 3;
+</pre>
+
+<h3 id="Inserção_Automática_de_Ponto-e-Vírgula">Inserção Automática de Ponto-e-Vírgula</h3>
+
+<p>A declaração <code>return</code> é afetada pela <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">inserção automática de ponto e vírgula (ASI)</a>. Nenhum terminador de linha é permitido entre a palavra-chave <code>return</code> e a expressão.</p>
+
+<pre class="brush: js">return
+a + b;
+</pre>
+
+<p>é transformado pelo ASI em:</p>
+
+<pre>return;
+a + b;
+</pre>
+
+<p>O console irá alertar "unreachable code after return statement" (código inacessível após a declaração return).</p>
+
+<div class="note">A partir do Gecko 40 {{geckoRelease(40)}}, um alerta é mostrado no console se um código inacessível é encontrado após uma declaração <code>return</code>.</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="return">return</h3>
+
+<p>A função a seguir retorna o quadro do seu argumento, <code>x</code>, quando <code>x</code> é um número.</p>
+
+<pre class="brush: js">function square(x) {
+   return x * x;
+}
+</pre>
+
+<h3 id="Interrompendo_uma_função">Interrompendo uma função</h3>
+
+<p>Uma função para imediatamente no ponto em que <code>return</code> é chamado.</p>
+
+<pre class="brush: js">function counter() {
+  for (var count = 1; ; count++) {  // loop infinito
+    console.log(count + 'A'); // até 5
+      if (count === 5) {
+        return;
+      }
+      console.log(count + 'B');  // até 4
+    }
+  console.log(count + 'C');  // nunca aparece
+}
+
+counter();
+
+// Saída:
+// 1A
+// 1B
+// 2A
+// 2B
+// 3A
+// 3B
+// 4A
+// 4B
+// 5A
+</pre>
+
+<h3 id="Retornando_uma_função">Retornando uma função</h3>
+
+<p>Veja também o artigo sobre <a href="/en-US/docs/Web/JavaScript/Closures">Closures</a>.</p>
+
+<pre class="brush: js">function magic(x) {
+  return function calc(x) { return x * 42; };
+}
+
+var answer = magic();
+answer(1337); // 56154
+</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.9', 'Return statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-return-statement', 'Return statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-return-statement', 'Return statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope" title="En/Core_JavaScript_1.5_Reference/Functions">Funções</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Closures">Closures</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/switch/index.html b/files/pt-br/web/javascript/reference/statements/switch/index.html
new file mode 100644
index 0000000000..ff47dd69d2
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/switch/index.html
@@ -0,0 +1,288 @@
+---
+title: switch
+slug: Web/JavaScript/Reference/Statements/switch
+tags:
+  - Instrução
+  - JavaScript
+  - Referência(2)
+  - Web
+translation_of: Web/JavaScript/Reference/Statements/switch
+---
+<div>
+<div>{{jsSidebar("Statements")}}</div>
+
+<div>A condicional <strong>switch </strong>avalia uma <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators">expressão</a>, combinando o valor da expressão para um cláusula <strong>case</strong>, e executa as <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements">instruções</a>  associadas ao <strong>case</strong>.</div>
+
+<div> </div>
+</div>
+
+<p id="sect1">{{EmbedInteractiveExample("pages/js/statement-switch.html")}}</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox">switch (expressão) {
+  case valor1:
+    //Instruções executadas quando o resultado da expressão for igual á valor1
+    [break;]
+  case valor2:
+    //Instruções executadas quando o resultado da expressão for igual á valor2
+    [break;]
+  ...
+  case valueN:
+    //Instruções executadas quando o resultado da expressão for igual á valorN
+    [break;]
+  default:
+    //Instruções executadas quando o valor da expressão é diferente de todos os cases
+    [break;]
+}</pre>
+
+<dl>
+ <dt><code>expressão</code></dt>
+ <dd>Uma expressão que será comparada á cada cláusula <strong>case</strong>.</dd>
+ <dt><code>case expressão</code></dt>
+ <dd>Uma cláusula <strong>case</strong> que será comparada á expressão.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Se a condição for correspondida, o programa executa as instruções asssociadas. Se múltiplos casos corresponderem o valor, o primeiro caso que corresponder é selecionado, mesmo se os casos não forem iguais entre si.</p>
+
+<p>O programa primeiro procura por um caso o qual a expressão avalie como tendo o mesmo valor que o input da expressão (usando a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">comparação de igualdade estrita</a>, <code>===) </code>transferindo assim o controle para a cláusula encontrada e em seguida execudando as instruções associadas. Caso nenhum caso seja correspondido, então o programa procura pela cláusula opicional <code>default</code>, que, se encontrado, tem o controle transferido à ele, executando suas instruções associadas. Se não ouver uma cláusula <code>default</code>, o programa continua a execução da instrução seguindo para o final do <code>switch</code>. Por convenção, a cláusula default é a última, mas não é algo obrigatório.</p>
+
+<p>A instrução opcional <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/break" title="JavaScript/Reference/Statements/break">break</a></code> associada com cada <code>case</code> garante que o programa saia da condicional <code>switch</code> assim que a instrução correspondente for executada  e executa a instrução que segue logo após o switch. Caso <code>break</code> seja omitido, o programa continua a execução para a próxima instrução dentro de <code>switch</code>. </p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Example:_Using_switch" name="Example:_Using_switch">Exemplo: Usando <code>switch</code></h3>
+
+<p>No exemplo a seguir, if <code>expr</code> é avaliado como "Bananas", o programa corresponde o valor com o <code>case</code> "Bananas" e executa a instrução associada. Quando <code>break</code> for encontrado, o programa para (break), saindo de <code>switch</code> e executa a instrução localizada após o <code>switch</code>. Se <code>break</code> fosse omitido, a instrução para "Cherries" também seria executada.</p>
+
+<pre class="brush: js">switch (expr) {
+  case "Laranjas":
+    console.log("As laranjas custam $0.59 o quilo.");
+    break;
+  case "Maçãs":
+    console.log("Maçãs custam $0.32 o quilo.");
+    break;
+  case "Bananas":
+    console.log("Bananas custam $0.48 o quilo.");
+    break;
+  case "Cerejas":
+    console.log("Cerejas custam $3.00 o quilo.");
+    break;
+  case "Mangas":
+  case "Mamões":
+    console.log("Mangas e mamões custam $2.79 o quilo.");
+    break;
+  default:
+    console.log("Desculpe, estamos sem nenhuma " + expr + ".");
+}
+
+console.log("Tem algo mais que você gostaria de levar?");
+</pre>
+
+<h3 id="What_happens_if_I_forgot_a_break" name="What_happens_if_I_forgot_a_break">Exemplo: O que acontece se eu esquecer um break?</h3>
+
+<p>Se você esquecer um break então o script irá rodar a partir do caso onde o critério foi correspondido e irá rodar também o caso seguinte independentemente do critério ter sido correspondido ou não:</p>
+
+<pre class="brush: js">var foo = 0;
+switch (foo) {
+    case -1:
+        console.log('1 negativo');
+        break;
+    case 0: // foo é 0 então aqui o critério foi correspondido, então esse bloco vai rodar
+        console.log(0)
+        // NOTA: o break esquecido deveria estar aqui
+    case 1: // nenhuma instrução break em 'case 0:' então essa instrução vai rodar também
+        console.log(1);
+        break; // o programa encontra esse break então não vai continuar para o 'case 2:'
+    case 2:
+        console.log(2);
+        break;
+    default:
+        console.log('default');
+}</pre>
+
+<h3 id="Methods_for_Multi-criteria_Case" name="Methods_for_Multi-criteria_Case">Exemplo: Métodos para múltiplos casos</h3>
+
+<p>Referência para esta técnica abaixo:</p>
+
+<p><a href="http://stackoverflow.com/questions/13207927/switch-statement-multiple-cases-in-javascript">- Switch statement multiple cases in JavaScript (Stack Overflow)</a></p>
+
+<h4 id="Multi-Caso_-_Operação_Simples">Multi-Caso - Operação Simples</h4>
+
+<p>Esse método toma vantagem do fato de não existir um break após um case e irá continuara  executar o próximo case independentemente se o case corresponde ao critério. Veja o título desta seção "O que acontece se eu esquecer um break?"</p>
+
+<p>Esse é um exemplo de uma operação sequencial simples com a instrução switch, onde quatro valores diferentes fazem a mesma coisa..</p>
+
+<p> </p>
+
+<pre class="brush: js">var Animal = 'Girafa';
+switch (Animal) {
+    case 'Vaca':
+    case 'Girafa':
+    case 'Cachorro':
+    case 'Porco':
+        alert('Esse animal irá para Arca de Noé');
+        break;
+    case 'Dinossauro':
+    default:
+        alert('Esse animal não vai.');
+}</pre>
+
+<h4 id="Multi-Caso_-_Operações_encadeadas">Multi-Caso - Operações encadeadas </h4>
+
+<p>Esse é um exemplo de múltiplas operações squenciais usando a instrução <code>switch</code>, onde, dependendo do número inteiro, você poderá receber outputs diferentes. Isso mostra que você pode alterar a ordem que você insere as instruções de <code>case</code>, e isso não precisa ser uma sequência numérica. Em JavaScript, você pode até mesmo misturar definições de strings dentro desses <code>cases</code>. </p>
+
+<p>This is an example of a multiple-operation sequential switch statement, where, depending on the provided integer, you can receive different output. This shows you that it wil traverse in the order that you put the case statements, and it does not have to be numerically sequential. In JavaScript, you can even mix in definitions of strings into these case statements as well.</p>
+
+<pre class="brush: js">var foo = 1;
+var output = 'Output: ';
+switch (foo) {
+    case 10:
+        output += 'Então ';
+    case 1:
+        output += 'Qual ';
+        output += 'É ';
+    case 2:
+        output += 'O Seu ';
+    case 3:
+        output += 'Nome';
+    case 4:
+        output += '?';
+        alert(output);
+        break;
+    case 5:
+        output += '!';
+        alert(output);
+        break;
+    default:
+        alert('Favor escolher um número de 0 à 6!');
+}</pre>
+
+<p>Output para esse exemplo:</p>
+
+<table class="standard-table" style="height: 270px; width: 522px;">
+ <tbody>
+  <tr>
+   <th scope="col">Value</th>
+   <th scope="col">Alert Text</th>
+  </tr>
+  <tr>
+   <td>foo é NaN ou não é 1, 2, 3, 4, 5 ou 10</td>
+   <td>Favor escolher um número de 0 à 6!</td>
+  </tr>
+  <tr>
+   <td>10</td>
+   <td>Output: Então Qual É O Seu Nome?</td>
+  </tr>
+  <tr>
+   <td>1</td>
+   <td>Output: Qual É O Seu Nome?</td>
+  </tr>
+  <tr>
+   <td>2</td>
+   <td>Output: Seu Nome?</td>
+  </tr>
+  <tr>
+   <td>3</td>
+   <td>Output: Nome?</td>
+  </tr>
+  <tr>
+   <td>4</td>
+   <td>Output: ?</td>
+  </tr>
+  <tr>
+   <td>5</td>
+   <td>Output: !</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Especificações">Especificações</h2>
+
+<p> </p>
+
+<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>ECMAScript 3ª Edição</td>
+   <td>Standard</td>
+   <td>Definição inicial.<br>
+    Implementado no JavaScript 1.2</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.11', 'switch statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-switch-statement', 'switch statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Característica</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">See also</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/if...else"><code>if...else</code></a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/throw/index.html b/files/pt-br/web/javascript/reference/statements/throw/index.html
new file mode 100644
index 0000000000..e8835f8d85
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/throw/index.html
@@ -0,0 +1,237 @@
+---
+title: throw
+slug: Web/JavaScript/Reference/Statements/throw
+tags:
+  - Instrução
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Statements/throw
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A <strong>declaração</strong> <strong><code>throw</code> </strong>lança uma exceção definida pelo usuário. A execução da função atual vai parar (as instruções após o <code>throw</code> não serão executadas), e o controle será passado para o primeiro bloco <a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch"><code>catch</code></a> na pilha de chamadas. Se nenhum bloco <code>catch</code> existe entre as funções "chamadoras", o programa vai terminar.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">throw <em>expressão</em>; </pre>
+
+<dl>
+ <dt><code>expressão</code></dt>
+ <dd>A expressão a ser lançada.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>Use a instrução <code>throw</code> para lançar uma exceção. Quando você lança uma exceção, <code>expressão</code> especifica o valor da exceção. Cada uma das intruções a seguir lança uma exceção:</p>
+
+<pre class="brush: js">throw "Erro2"; // gera uma exceção com um valor string
+throw 42;      // gera uma exceção com o valor 42
+throw true;    // gera uma exceção com o valor true</pre>
+
+<p>Note também que a instrução <code>throw</code> é afetada pela <a href="/en-US/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">inserção automática de ponto-e-vírgula (ASI)</a> como nenhum terminador de linha entre a palavra <code>throw</code> e a expressão é permitido.</p>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Lançando_um_objeto">Lançando um objeto</h3>
+
+<p>Você pode especificar um objeto quando você lança uma exceção. Você pode então referenciar as propriedades do objeto no bloco <code>catch</code>. O exemplo a seguir cria um objeto do tipo <code>UserException</code> e o usa na intrução <code>throw</code>.</p>
+
+<pre class="brush: js">function UserException(message) {
+   this.message = message;
+   this.name = "UserException";
+}
+function getMonthName(mo) {
+   mo = mo-1; // Ajusta o número do mês para index de array (1=Jan, 12=Dec)
+   var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
+      "Aug", "Sep", "Oct", "Nov", "Dec"];
+   if (months[mo] !== undefined) {
+      return months[mo];
+   } else {
+      throw new UserException("InvalidMonthNo");
+   }
+}
+
+try {
+   // statements to try
+   var myMonth = 15; // 15 is out of bound to raise the exception
+   monthName = getMonthName(myMonth);
+} catch (e) {
+   monthName = "unknown";
+   logMyErrors(e.message, e.name); // pass exception object to err handler
+}
+</pre>
+
+<h3 id="Outro_exemplo_lançando_um_objeto">Outro exemplo lançando um objeto</h3>
+
+<p>O exemplo a seguir testa uma string de entrada para um cep dos Estados Unidos. Se o CEP utiliza um formato inválido, a intrução throw lança uma exceção através da criação de um objeto do tipo <code>ZipCodeFormatException</code>.</p>
+
+<pre class="brush: js">/*
+ * Cria um objeto ZipCode.
+ *
+ * Formatos aceitos para o CEP são:
+ *    12345
+ *    12345-6789
+ *    123456789
+ *    12345 6789
+ *
+ * Se o argumento passado para o construtor do ZipCode não atende
+ * a um desses padrões uma exceção é lançada.
+ */
+
+function ZipCode(zip) {
+   zip = new String(zip);
+   pattern = /[0-9]{5}([- ]?[0-9]{4})?/;
+   if (pattern.test(zip)) {
+      // o valor do CEP será a primeira combinação na string
+      this.value = zip.match(pattern)[0];
+      this.valueOf = function() {
+         return this.value
+      };
+      this.toString = function() {
+         return String(this.value)
+      };
+   } else {
+      throw new ZipCodeFormatException(zip);
+   }
+}
+
+function ZipCodeFormatException(value) {
+   this.value = value;
+   this.message = "does not conform to the expected format for a zip code";
+   this.toString = function() {
+      return this.value + this.message;
+   };
+}
+
+/*
+ * Isso poderia estar em um script que valida dados de endereços
+ * para os endereços dos Estados Unidos.
+ */
+
+const ZIPCODE_INVALID = -1;
+const ZIPCODE_UNKNOWN_ERROR = -2;
+
+function verifyZipCode(z) {
+   try {
+      z = new ZipCode(z);
+   } catch (e) {
+      if (e instanceof ZipCodeFormatException) {
+         return ZIPCODE_INVALID;
+      } else {
+         return ZIPCODE_UNKNOWN_ERROR;
+      }
+   }
+   return z;
+}
+
+a = verifyZipCode(95060);         // retorna 95060
+b = verifyZipCode(9560);          // retorna -1
+c = verifyZipCode("a");           // retorna -1
+d = verifyZipCode("95060");       // retorna 95060
+e = verifyZipCode("95060 1234");  // retorna 95060 1234
+</pre>
+
+<h3 id="Relançando_uma_exceção">Relançando uma exceção</h3>
+
+<p>Você pode usar <code>throw</code> para relançar uma exceção após você pegá-la. O exemplo a seguir pega uma exceção com um valor numérico e a relança se o valor for maior que 50. A exceção relançada propaga para a função encapsuladora ou para o nível superior para que o usuário a veja.</p>
+
+<pre class="brush: js">try {
+   throw n; // lança uma exceção com um valor numérico
+} catch (e) {
+   if (e &lt;= 50) {
+      // instruções para tratar exceções 1-50
+   } else {
+      // não pode tratar esta exceção então relança
+      throw e;
+   }
+}
+</pre>
+
+<h2 id="Specifications">Specifications</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>{{SpecName('ES3')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td>Definição inicial. Implementada no JavaScript 1.4</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.13', 'throw statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-throw-statement', 'throw statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-throw-statement', 'throw statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_browser">Compatibilidade de browser</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Funcionalidade</th>
+   <th>Android</th>
+   <th>Chrome para Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/try...catch"><code>try...catch</code></a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/try...catch/index.html b/files/pt-br/web/javascript/reference/statements/try...catch/index.html
new file mode 100644
index 0000000000..001e7fcc13
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/try...catch/index.html
@@ -0,0 +1,249 @@
+---
+title: try...catch
+slug: Web/JavaScript/Reference/Statements/try...catch
+translation_of: Web/JavaScript/Reference/Statements/try...catch
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>As declarações <strong>try...catch</strong> marcam um bloco de declarações para testar (<strong>try</strong>),  e especifica uma resposta, caso uma exceção seja lançada.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox">try {
+   <em>try_statements</em>
+}
+[catch (<em>exception_var_1</em> if <em>condition_1</em>) {
+   <em>catch_statements_1</em>
+}]
+...
+[catch (<em>exception_var_2</em>) {
+   <em>catch_statements_2</em>
+}]
+[finally {
+   <em>finally_statements</em>
+}]
+</pre>
+
+<dl>
+ <dt><code>try_statements</code></dt>
+ <dd>Declarações (statements) a serem executadas.</dd>
+</dl>
+
+<dl>
+ <dt><code>catch_statements_1</code>, <code>catch_statements_2</code></dt>
+ <dd>Declarações que são executadas se uma exceção é lançada no bloco <code style="font-style: normal; line-height: 1.5;">try.</code></dd>
+</dl>
+
+<dl>
+ <dt><code>exception_var_1</code>, <code>exception_var_2</code></dt>
+ <dd>Um indentificador que leva um objeto exceção para uma cláusula <code>catch</code>  associada.</dd>
+</dl>
+
+<dl>
+ <dt><code>condition_1</code></dt>
+ <dd>Uma expressão condicional.</dd>
+</dl>
+
+<dl>
+ <dt><code>finally_statements</code></dt>
+ <dd>Declarações que são executadas depois que a declaração <code>try</code> é completada. Essas declarações são executadas independetemente se uma exceção foi ou não lançada ou capturada.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>A declaração <code>try</code> consiste  em um bloco <code>try</code>, que contém uma ou mais declarações, e ao menos uma cláusula <code>catch</code>  ou uma cláusula <code>finally</code>,  ou ambas. Ou seja, há 3 formas de declarações <code>try</code> :</p>
+
+<ol>
+ <li><code>try...catch</code></li>
+ <li><code>try...finally</code></li>
+ <li><code>try...catch...finally</code></li>
+</ol>
+
+<p>Uma cláusula <code>catch</code> contém declarações que especificam o que fazer caso uma exceção seja lançada no bloco <code>try</code>. Ou seja, se você quer que o bloco <code>try </code>tenha êxito, e caso não tenha, você quer que o controle passe para o bloco <code>catch</code>. Caso qualquer declaração dentro do bloco <code>try</code>  (ou em uma função chamada no interior do bloco <code>try</code>) lançar uma exceção o controle imediatamente muda para a cláusula <code>catch</code>. Se nenhuma exceção for lançada no bloco <code>try</code> a cláusula <code>catch</code> é ignorada.</p>
+
+<p>A cláusula <code>finally</code> é executada após a excecução do bloco <code>try</code> e da(s) cláusula(s) <code>catch </code>porém antes das declarações seguintes ao <code>try</code>. Ela sempre é executada, independente se uma exceção for lançada ou capturada.</p>
+
+<p>Você pode aninhar uma ou mais declarações <code>try</code>. Caso uma declaração <code>try</code> interior não tenha uma cláusula <code>catch</code>, a cláusula catch pertencente a declaração <code>try</code> que a envolve é introduzida. </p>
+
+<p>Você pode usar a declaração try para manipular exceções em JavaScript. Veja o <a href="/pt-BR/docs/Web/JavaScript/Guide">Guia Javascript</a> para informações sobre exceções em JavaScript.</p>
+
+<h3 id="Unconditional_catch_clause" name="Unconditional_catch_clause">Cláusula catch incondicional</h3>
+
+<p>Quando uma única, incondicional cláusula <code>catch</code> é utilizada, o bloco <code>catch</code>  é inserido quando qualquer exceção for lançada. Por exemplo, quando a exceção ocorre no código a seguir, o controle é transferido para a cláusula <code>catch</code>.</p>
+
+<pre class="brush: js">try {
+   throw "myException"; // gera uma exceção
+}
+catch (e) {
+   // declarações para manipular quaisquer exceções
+   logMyErrors(e); // <code>passa o objeto de exceção para o manipulador de erro</code>
+}
+</pre>
+
+<h3 id="Conditional_catch_clauses" name="Conditional_catch_clauses">Cláusulas <code>catch</code> condicionais</h3>
+
+<p>{{non-standard_header}}</p>
+
+<p>Você pode utilizar uma ou mais cláusulas <code>catch</code> condicionals para manipular exceções específicas. Nesse caso a cláusula <code>catch</code> apropriada será inserida quando a exceção espeficica for lançada. No exemplo a seguir, o código no bloco <code>try</code> pode potencialmente jogar três exceções: <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/TypeError"><code>TypeError</code></a>, <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/RangeError"><code>RangeError</code></a>, e <a href="/pt-BR/docs/Web/JavaScript/Reference/Global_Objects/EvalError"><code>EvalError</code></a>. Quando a exceção ocorre, o controle transfere para a cláusula <code>catch</code> apropriada. Caso a exceção não seja uma das especificadas e uma cláusula <code>catch</code> incondicional for encontrada, o controle é transferido para essa cláusula <code>catch</code>.</p>
+
+<p>Se utilizar uma cláusula <code>catch</code> incondicional com uma ou mais cláusulas <code>catch</code> condicionais, o catch incondicional deve ser especificado por último. Caso contrário, o catch incondicional interceptará todos os tipos de exceção antes que eles alcancem os condicionais.</p>
+
+<p>Nota: Essa funcionalidade não é parte da especificação ECMAScript.</p>
+
+<pre><code>try {
+    myroutine(); // </code>pode lançar três tipos de exceções<code>
+} catch (e if e instanceof TypeError) {
+    // declarações para manipular exceções TypeError
+} catch (e if e instanceof RangeError) {
+    // declarações para manipular exceções RangeError
+} catch (e if e instanceof EvalError) {
+    // declarações para manipular exceções EvalError
+} catch (e) {
+    // declarações para manipular quaisquer exceções não especificadas
+    logMyErrors(e); // passa o objeto de exceção para o manipulador de erro
+}</code></pre>
+
+<p>E aqui temos como implementar as mesmas "cláusulas <code>catch</code> condicionais" utilizando apenas JavaScript puro conforme a especificação ECMAScript (obviamente é mais verboso, porém, funciona em qualquer lugar):</p>
+
+<pre><code>try {
+    myroutine(); </code>// pode lançar três tipos de exceções<code>
+} catch (e) {
+    if (e instanceof TypeError) {
+        // declarações para manipular exceções TypeError
+    } else if (e instanceof RangeError) {
+        // declarações para manipular exceções RangeError
+    } else if (e instanceof EvalError) {
+        // declarações para manipular exceções EvalError
+    } else {
+       // declarações para manipular quaisquer exceções não especificadas
+       logMyErrors(e); // passa o objeto de exceção para o manipulador de erro
+    }
+}</code>
+</pre>
+
+<h3 id="The_exception_identifier" name="The_exception_identifier">O identificador de exceção</h3>
+
+<p>Quando uma exceção é lançada no bloco <code>try</code>, <em><code>exception_var</code></em> (ex. o <code>e</code> dentro de <code>catch (e)</code>) armazena o valor especificado pela declaração <code>throw</code>. Você pode usar esse identificador para conseguir informação sobre a exceção que foi lançanda.</p>
+
+<p>Esse identificador é local para a cláusula <code>catch</code>. Ou seja, é criado quando a cláusula <code>catch</code> é introduzida e após terminar sua excecução o identificador não se torna mais disponível.</p>
+
+<h3 id="The_finally_clause" name="The_finally_clause">A cláusula <code>finally</code></h3>
+
+<p>A cláusula <code>finally</code> é executada após a excecução do bloco <code>try</code> e da(s) cláusula(s) <code>catch </code>porém antes das declarações seguintes a declaração <code>try</code>. Ela sempre é executada, independente se uma exceção for lançada ou capturada.</p>
+
+<p>A cláusula <code>finally</code> contém declarações para executarem após a execução do bloco <code>try</code>  e da(s) cláusula(s) <code>catch </code> porém antes das declarações seguintes a declaração <code>try</code>. A cláusula <code>finally</code> é excutada independente se uma exceção for lançada ou não. Caso uma exceção seja lançada, as declarações no interior da cláusula <code>finally</code> são executadas mesmo que nenhum <code>catch</code> manipule a exceção.</p>
+
+<p>Você pode utilizar a cláusula <code>finally</code> para fazer seu script falhar graciosamente quando uma exceção ocorrer; por exemplo, você pode precisar liberar um recurso que seu script possui vinculado. O exemplo seguinte abre um aquivo e então executa declarações que utilizam o arquivo (server-side JavaScript permite que você acesse arquivos). Se uma exceção for lançada enquanto o arquivo estiver aberto, a cláusula <code>finally</code> fecha o arquivo antes que o script falhe.</p>
+
+<pre class="brush: js">openMyFile()
+try {
+   // vincula o recurso
+   writeMyFile(theData);
+}
+finally {
+   closeMyFile(); // sempre fecha o recurso
+}
+</pre>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Blocos_try_aninhados">Blocos try aninhados</h3>
+
+<p>Primeiro vamos ver o que acontece com isso:</p>
+
+<pre><code><span class="kwd">try</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+  </span><span class="kwd">try</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    </span><span class="kwd">throw</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">Error</span><span class="pun">(</span><span class="str">"oops"</span><span class="brush: js">);</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+  </span><span class="kwd">finally</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    console</span><span class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"finally"</span><span class="pun">);</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+</span><span class="pun">}</span><span class="pln">
+</span><span class="kwd">catch</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ex</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+  console</span><span class="pun">.</span><span class="pln">error</span><span class="pun">(</span><span class="str">"outer"</span><span class="pun">,</span><span class="pln"> ex</span><span class="pun">.</span><span class="pln">message</span><span class="pun">);</span><span class="pln">
+</span><span class="pun">}</span></code>
+
+// Resultado
+<code><span class="str">// "finally"<span class="pln">
+</span>// "outer"</span><span class="pln"> </span><span class="str">"oops"</span></code></pre>
+
+<p>Agora, caso nós já capturamos a exceção no bloco <code>try</code> interno adicionando um bloco <code>catch</code></p>
+
+<pre><code><span class="kwd"><code><span class="kwd">try {
+  try {
+    throw new Error("oops");
+  }
+  catch (ex) {
+    console.error("inner", ex.message);
+  }
+  finally {
+    console.log("finally");
+  }
+}
+catch (ex) {
+  console.error("outer", ex.message);
+}</span></code></span></code>
+
+// Resultado:
+<code><span class="str">// "inner"<span class="pln"> </span>"oops"</span><span class="pln">
+</span><span class="str">// "finally"</span></code></pre>
+
+<p>E agora, vamos relançar o erro.</p>
+
+<pre><code><span class="kwd"><code><span class="kwd"><code><span class="kwd">try</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+  </span><span class="kwd">try</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    </span><span class="kwd">throw</span><span class="pln"> </span><span class="kwd">new</span><span class="pln"> </span><span class="typ">Error</span><span class="pun">(</span><span class="str">"oops"</span><span class="pun">);</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+  </span><span class="kwd">catch</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ex</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    console</span><span class="pun">.</span><span class="pln">error</span><span class="pun">(</span><span class="str">"inner"</span><span class="pun">,</span><span class="pln"> ex</span><span class="pun">.</span><span class="pln">message</span><span class="pun">);</span><span class="pln">
+    </span><span class="kwd">throw</span><span class="pln"> ex</span><span class="pun">;</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+  </span><span class="kwd">finally</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+    console</span><span class="pun">.</span><span class="pln">log</span><span class="pun">(</span><span class="str">"finally"</span><span class="pun">);</span><span class="pln">
+  </span><span class="pun">}</span><span class="pln">
+</span><span class="pun">}</span><span class="pln">
+</span><span class="kwd">catch</span><span class="pln"> </span><span class="pun">(</span><span class="pln">ex</span><span class="pun">)</span><span class="pln"> </span><span class="pun">{</span><span class="pln">
+  console</span><span class="pun">.</span><span class="pln">error</span><span class="pun">(</span><span class="str">"outer"</span><span class="pun">,</span><span class="pln"> ex</span><span class="pun">.</span><span class="pln">message</span><span class="pun">);</span><span class="pln">
+</span><span class="pun">}</span></code></span></code></span>
+
+// Resultado:</code>
+<code><span class="str">// "inner"</span><span class="pln"> </span><span class="str">"oops"</span></code>
+<code><span class="str">// "finally"</span></code>
+<code><span class="str">// "outer"</span><span class="pln"> </span><span class="str">"oops"</span></code>
+</pre>
+
+<p>Qualquer exceção lançada será capturada apenas uma vez pelo bloco <code>catch</code> envolvente mais próximo, a não ser que seja relançada. Obviamente qualquer nova exceção elevada no bloco "interno" (pois código em um bloco <code>catch</code> pode fazer algo que lance), será capturado pelo bloco "externo".</p>
+
+<h3 id="Retornando_de_um_bloco_finnaly">Retornando de um bloco <code>finnaly</code></h3>
+
+<p>Caso o bloco f<code>inally</code> retorne um valor, esse valor torna-se o valor de retorno do produto de <code>try-catch-finally </code>inteiro, independente de qualquer declaração return nos blocos <code>try</code> e <code>catch</code>. Isso inclui exceções lançadas dentro do bloco <code>catch</code>:</p>
+
+<pre><code>try {
+  try {
+    throw new Error("oops");
+  }
+  catch (ex) {
+    console.error("inner", ex.message);
+    throw ex;
+  }
+  finally {
+    console.log("finally");
+    return;
+  }
+}
+catch (ex) {
+  console.error("outer", ex.message);
+}</code>
+
+// Resultado:
+// "inner" "oops"
+// "finally"</pre>
+
+<p>O "oops" externo não é lançado devido ao retorno do bloco f<code>inally</code>. O mesmo se aplicaria a qualquer valor retornado do bloco <code>catch</code>.</p>
+
+<h2 id="See_also" name="See_also">Vejam também</h2>
+
+<ul>
+ <li><a href="/en/JavaScript/Reference/Statements/throw" title="en/JavaScript/Reference/Statements/throw">throw</a></li>
+ <li><a href="/en/JavaScript/Reference/Global_Objects/Error" title="https://developer.mozilla.org/en/JavaScript/Reference/Global_Objects/Error">Error</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/var/index.html b/files/pt-br/web/javascript/reference/statements/var/index.html
new file mode 100644
index 0000000000..6f3ec18977
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/var/index.html
@@ -0,0 +1,238 @@
+---
+title: var
+slug: Web/JavaScript/Reference/Statements/var
+tags:
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Statements/var
+---
+<div>
+<div>{{jsSidebar("Statements")}}</div>
+</div>
+
+<h2 id="Sumário">Sumário</h2>
+
+<p>O <strong><code>variable</code> statement</strong> declara uma variável, opcionalmente é possível atribuir à ela um valor em sua inicialização.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox">var <em>varname1 [</em>= <em>value1 [</em>, <em>varname2 [</em>, <em>varname3 ... [</em>, <em>varnameN]]]]</em>;</pre>
+
+<dl>
+ <dt><code>varnameN</code></dt>
+ <dd>Nome da variável. Pode ser utilizado qualquer identificador legal.</dd>
+</dl>
+
+<dl>
+ <dt><code>valueN</code></dt>
+ <dd>Valor inicial da variável. Pode ser qualquer expressão legal.</dd>
+</dl>
+
+<h2 id="Description" name="Description">Descrição</h2>
+
+<p>Declarações de variáveis, onde quer que elas ocorram, são processadas antes que qualquer outro código seja executado. O escopo de uma variável declarada com  <code>var</code> é seu contexto atual em execução, o qual é a função a qual pertence ou, para variáveis declaradas fora de qualquer função, o escopo é o global.</p>
+
+<p>Atribuir um valor a uma variável não declarada anteriormente implica em criar uma variável global (ela se torna uma propriedade do objeto global) quando a atribuição é executada. As diferenças entre uma variável declarada e uma não delcarada são:</p>
+
+<p>1. Variáveis declaradas estão relacionadas com o contexto de execução quando elas são criadas (por exemplo, uma função, objeto). Por outro lado, as variaveis não declaradas sempre são globais.</p>
+
+<pre class="brush: js">function x() {
+  y = 1;   // Lança a exceção ReferenceError em modo restrito (strict mode)
+  var z = 2;
+}
+
+x();
+
+console.log(y); // logs "1"
+console.log(z); // Lança a exceção ReferenceError: z não foi definida fora da função x()
+</pre>
+
+<p>2. Variáveis declaradas são criadas antes de qualquer código ser executado. As variáveis não declaradas não existem até quando o código atribuir um valor a ela.</p>
+
+<pre class="brush: js">console.log(a);                // Lança a exceção ReferenceError.
+console.log('still going...'); // Nunca será executado.</pre>
+
+<pre class="brush: js">var a;
+console.log(a);                // mostra "undefined" ou "" dependendo do naveador.
+console.log('still going...'); // mostra "still going...".</pre>
+
+<p>3. Variáveis declaradas são propriedades não configuráveis no contexto de execução (função ou global). Variaveis não declaradas são configuráveis (por exemplo, podem ser excluídas).</p>
+
+<pre class="brush: js">var a = 1;
+b = 2;
+
+delete this.a; // Lança a exceção TypeError em modo restrito(strict mode). Caso contrário, Falha silenciosamente.
+delete this.b;
+
+console.log(a, b); // Throws a ReferenceError.
+// A propriedade 'b' foi deletada e não existe mais.</pre>
+
+<p>Por conta dessas três diferenças, falha para declarar variáveis, muito provavelmente, levar a resultados inesperados. <strong>Então, é recomendado sempre declarar as variáveis, independentemente se as variáveis estão em escopo de função ou escopo global</strong>. E o modo restrito (<a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">strict mode</a>) do ECMAScript 5 sempre lançará uma exceçao quando o código atribuir um valor a uma variável não declarada.</p>
+
+<h3 id="var_hoisting">var hoisting</h3>
+
+<p>Como as declarações de variáveis (e declarações em geral) são processadas antes de qualquer código seja executado, declarar uma variável em qualquer lugar no código é equivalente a declarar no inicio. Isso também significa que uma variável pode aparecer para ser usada antes dela ser declarada. Esse comportamento é chamado de "hoisting", a variável é movida para o inicio da função ou do código global.</p>
+
+<pre class="brush: js">bla = 2
+var bla;
+// ...
+
+// é implicitamente entendido como:
+
+var bla;
+bla = 2;
+</pre>
+
+<p>Por essa razão, recomenda-se sempre declarar variáveis na parte superior do seu escopo de aplicação (o topo do código global e a parte superior do código da função). Por isso, é claro que as variáveis são função de escopo (local) e que são resolvidos na cadeia de escopo.</p>
+
+<h2 id="Examples" name="Examples">Exemplos</h2>
+
+<h3 id="Declarando_e_inicializando_duas_variáveis">Declarando e inicializando duas variáveis</h3>
+
+<pre class="brush: js">var a = 0, b = 0;
+</pre>
+
+<h3 id="Atribuindo_duas_variáveis_com_uma_única_expressão">Atribuindo duas variáveis com uma única expressão</h3>
+
+<pre class="brush: js">var a = "A";
+var b = a;
+
+// Equivalente a:
+
+var a, b = a = "A";
+</pre>
+
+<p>É sempre importante lembrar da ordem da declaração das variáveis:</p>
+
+<pre class="brush: js">var x = y, y = 'A';
+console.log(x + y); // undefinedA
+</pre>
+
+<p>Então, <span style="font-family: consolas,monaco,andale mono,monospace;">x</span> e <span style="font-family: consolas,monaco,andale mono,monospace;">y</span> são declarados antes de qualquer código seja executado, a atribuição ocorre posteriormente. Quando "<span style="font-family: consolas,monaco,andale mono,monospace;">x = y</span>" for executado, y existe e nenhum exceção <span style="font-family: consolas,monaco,andale mono,monospace;">ReferenceError</span> é lançada, e o valor de y será considerado como '<code style="font-style: normal;">undefined</code>'. Por este motivo, este valor é atribuido a <span style="font-family: consolas,monaco,andale mono,monospace;">x</span>. Depois disso, o valor 'A' é atribuido a variável <span style="font-family: consolas,monaco,andale mono,monospace;">y</span>. Consequentemente, depois da primeira linha, <span style="font-family: consolas,monaco,andale mono,monospace;">x === undefined &amp;&amp; y === 'A'</span>, então o resultado.</p>
+
+<h3 id="Iniciando_diversas_variáveis">Iniciando diversas variáveis</h3>
+
+<pre class="brush: js">var x = 0;
+
+function f(){
+  var x = y = 1; // x é declarado localmente,y não é!
+}
+f();
+
+console.log(x, y); // 0, 1
+// x é uma variável global como experado
+// y vazou para fora da função!</pre>
+
+<h3 id="Variável_global_implícita_e_fora_do_escopo_da_função">Variável global implícita e fora do escopo da função</h3>
+
+<p>Variáveis que aparecem como variáveis globais implicitas podem ser referenciadas como variáveis fora do escopo da função:</p>
+
+<pre class="brush: js">var x = 0;  // x é declarada como global e é igual a 0
+
+console.log(typeof z); // undefined, desde que z não tenha sido criada anteriormente
+
+function a() { // quando a for chamada,
+  var y = 2;   // y é declarada como local desta função, e o valor 2 é atribuido
+
+  console.log(x, y);   // 0 2
+
+  function b() {       // quando b for chamado,
+    x = 3;  // atribui o valor 3 a variável global existente, ele não cria uma nova variável global
+    y = 4;  // atribui o valor 4 a uma variável fora, ele não cria uma nova variável
+    z = 5;  // cria uma nova variável global e atribui o valor 5.
+  }         // (Lança a exceção ReferenceError em modo restrito.)
+
+  b();     // chamando b, o código irá criar z como variável global
+  console.log(x, y, z);  // 3 4 5
+}
+
+a();                   // chamando a, também irá chamar b
+console.log(x, z);     // 3 5
+console.log(typeof y); // indefinido já que y é uma variável local da função a</pre>
+
+<h2 id="Especificação">Especificação</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>Primeira definição.<br>
+    Implementada no JavaScript 1.0</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.2', 'var statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-variable-statement', 'variable statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_dos_Navegadores">Compatibilidade dos Navegadores</h2>
+
+<p>{{ CompatibilityTable() }}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+   <td>{{ CompatVersionUnknown() }}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="See_also" name="See_also">Veja também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/let"><code>let</code></a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/const"><code>const</code></a></li>
+ <li><a class="external" href="http://blog.safeshepherd.com/23/how-one-missing-var-ruined-our-launch/">How One Missing `var` Ruined our Launch</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/while/index.html b/files/pt-br/web/javascript/reference/statements/while/index.html
new file mode 100644
index 0000000000..70fbb3e2f9
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/while/index.html
@@ -0,0 +1,142 @@
+---
+title: while
+slug: Web/JavaScript/Reference/Statements/while
+tags:
+  - Declaração
+  - JavaScript
+translation_of: Web/JavaScript/Reference/Statements/while
+---
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A <strong>declaração while</strong> cria um laço que executa uma rotina especifica enquanto a condição de teste for avaliada como verdadeira. A condição é avaliada antes da execução da rotina.</p>
+
+<h2 id="Syntax">Syntax</h2>
+
+<pre class="syntaxbox">while (<code>condição</code>) {
+  rotina
+}</pre>
+
+<dl>
+ <dt><code>condição</code></dt>
+ <dd>Uma expressão avaliada antes de cada passagem através do laço. Se essa condição for avaliada como verdadeira, a rotina é executada. Quando a condição for avaliada como falsa, a execução continua na declaração depois do laço<code> while</code>.</dd>
+ <dt>rotina</dt>
+ <dd>Uma declaração que é executada enquanto a condição é avaliada como verdadeira. Para executar multiplas declarações dentro de um laço, use uma declaração em <a href="/en-US/docs/" title="JavaScript/Reference/Statements/block">bloco</a> (<code>{ ... }</code>) para agrupar essas declarações.</dd>
+</dl>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<p>O seguinte laço <code>while</code> itera enquanto n é menor que três.</p>
+
+<pre class="brush:js">var n = 0;
+var x = 0;
+
+while (n &lt; 3) {
+  n++;
+  x += n;
+}</pre>
+
+<p>Cada iteração, o laço incrementa n e soma à x. Portanto, x e n assumem os seguintes valores:</p>
+
+<ul>
+ <li>Depois da primeira passagem: n = 1 e x = 1</li>
+ <li>Depois da segunda passagem: n = 2 e x = 3</li>
+ <li>Depois da terceira passagem: n = 3 e x = 6</li>
+</ul>
+
+<p>Depois de completar a terceira passagem, a condição n &lt; 3 não é mais verdadeira, então o laço termina.</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>{{SpecName('ESDraft', '#sec-while-statement', 'while statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-while-statement', 'while statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.6.2', 'while statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-12.6.2', 'while statement')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-12.6.1', 'while statement')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_nos_browsers">Compatibilidade nos browsers</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Suporte básico</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_Também">Veja Também</h2>
+
+<ul>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Statements/do...while"><code>do...while</code></a></li>
+ <li>{{jsxref("Statements/for", "for")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/statements/with/index.html b/files/pt-br/web/javascript/reference/statements/with/index.html
new file mode 100644
index 0000000000..0d18576236
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/statements/with/index.html
@@ -0,0 +1,183 @@
+---
+title: with
+slug: Web/JavaScript/Reference/Statements/with
+tags:
+  - Declaração
+  - Deprecado
+  - Deprecated
+  - JavaScript
+  - Statement
+translation_of: Web/JavaScript/Reference/Statements/with
+---
+<div class="warning">O uso da declaração <code>with</code> não é recomendado, isso porque ele pode ser a fonte de bugs confusos e problemas de compatibilidade. Veja o parágrafo "Contra de ambiguidade" na seção "Descrição" para mais detalhes.</div>
+
+<div>{{jsSidebar("Statements")}}</div>
+
+<p>A <strong>declaração with</strong> extende a cadeia de escopo para uma declaração.</p>
+
+<h2 id="Sintaxe">Sintaxe</h2>
+
+<pre class="syntaxbox">with (expressão)
+  <em>declaração</em>
+</pre>
+
+<dl>
+ <dt><code>expressão</code></dt>
+ <dd>Adiciona a dada expressão à cadeia de escopo quando estiver avaliando a declaração. O parênteses em volta da expressão é obrigatório.</dd>
+ <dt><code>declaração</code></dt>
+ <dd>Qualquer declaração. Para executação multiplas declarações, utilize a declaração em <a href="/en-US/docs/Web/JavaScript/Reference/Statements/block" title="JavaScript/Reference/Statements/block">bloco</a> ({ ... }) para agrupar estas declarações.</dd>
+</dl>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p>JavaScript procura por um nome não qualificado procurando uma cadeia de escopo associada à execução do contexto do script ou função contendo um nome não qualificado. A declaração 'with' adiciona o dado objeto à frenet dessa cadeia de escopo durante a validação desse corpo de declarações. Se um nome não qualificado usado no corpo for igual ao de uma propriedade na cadeia de escopo,  então o nome ficará ligado à propriedade e ao objeto contendo a propriedade. Senão, um {{jsxref("ReferenceError")}} será invocado.</p>
+
+<div class="note">Usar <code>with</code> não é recomendado, e está probido no <a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode" title="JavaScript/Strict mode">strict mode</a> do ECMAScript 5. A alternativa recomendada é atribuir o objeto cujas propriedades você quer acessar a uma variável temporária.</div>
+
+<h3 id="Pros_contras_de_perfomance">Pros &amp; contras de perfomance</h3>
+
+<p><strong>Pro:</strong> A declaração <code>with</code> pode ajudar o tamanho do arquivo por reduzir a necessidade de repetir a referência a um objeto longo sem penalidade na perfomance. A cadeia de escopo mudada por um 'with' não é computacionalmente cara. O uso de 'with' irá aliviar o interpretador de tratar repetidamente as referências. Note que, no entando, isso em muitos casos pode ser substituído usando uma variável temporária para armazenar a referência do objeto desejado.</p>
+
+<p><strong>Contra:</strong> A declaração <code>with</code> força que o objeto especifícado a ser procurado primeiro por pesquisas de nome. Assim sendo, todos os indentificadores que não são membros do objeto espeficícado vão ser encontrados mais lentamente em um bloco 'with'. Onde a perfomance é importande, 'with' deve ser usado apenas para englobar blocos de código que acessam membros de um objeto especifíco.</p>
+
+<h3 id="Contra_de_ambiguidade">Contra de ambiguidade</h3>
+
+<p><strong>Contra:</strong> A declaração <code>with</code> faz ser difícil para um leitor humano ou compilador JavaScript decidir se um nome não qualificado var se encontrado em uma cadeia de escopo, e também, em qual objeto. Dado o exemplo seguinte:</p>
+
+<pre class="brush: js">function f(x, o) {
+  with (o) {
+    console.log(x);
+  }
+}</pre>
+
+<p>Apenas quando <code>f</code> é chamado é <code>x</code> ou encontrado ou não, e se for encontrado, ou em <code>o</code> ou (se nenhuma propriedade existir) no objeto de ativação de <code>f</code>, onde o nome de <code>x</code> é o primeiro argumento formal. Se você esquecer de definir <code>x</code> no objeto que você passou como segundo argumento, ou se há algum bug similar ou confusão, você não vai receber um erro -- apenas resultados inesperados.</p>
+
+<p><strong>Contra: </strong>Código utilizando <code>with</code> talvez não seja compatível posteriormente, especialmente quando usado com algo que não seja um objeto simples. Considere esse exemplo:</p>
+
+<div>
+<pre class="brush:js">function f(foo, values) {
+  with (foo) {
+    console.log(values);
+  }
+}
+</pre>
+
+<p>Se você chamar <code>f([1,2,3], obj)</code> em um ambiente ECMAScript 5, então a referência de <code>values</code> dentro da declaração <code>with</code> irá ser <code>obj</code>. No entando, ECMAScript 6 introduz uma propriedade <code>values</code> no <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype">Array.prototype</a></code> (então isso estará disponível em todas as arrays). Então, em um ambiente JavaScript que suporta ECMAScript 6, a referência de <code>values</code> dentro da declaração <code>with</code> irá ser <code>[1,2,3].values</code>.</p>
+</div>
+
+<h2 id="Exemplos">Exemplos</h2>
+
+<h3 id="Usando_with">Usando <code>with</code></h3>
+
+<p>A seguinte declaração <code>with</code> irá especificar que o objeto <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math" title="JavaScript/Reference/Global_Objects/Math"><code>Math</code></a> é o objeto padrão. As seguintes declarações seguindo a declaração <code>with</code> irão referir a propriedade <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/PI" title="JavaScript/Reference/Global_Objects/Math/PI"><code>PI</code></a> e aos métodos <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/cos" title="JavaScript/Reference/Global_Objects/Math/cos"><code>cos</code></a> e <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin" title="JavaScript/Reference/Global_Objects/Math/sin"><code>sin</code></a>, sem especificar um objeto. JavaScript assume o objeto <code>Math</code> para essas referências.</p>
+
+<pre class="brush:js">var a, x, y;
+var r = 10;
+
+with (Math) {
+  a = PI * r * r;
+  x = r * cos(PI);
+  y = r * sin(PI / 2);
+}</pre>
+
+<h2 id="Especificações">Especificações</h2>
+
+<table class="standard-table">
+ <tbody>
+  <tr>
+   <th scope="col">Especificação</th>
+   <th scope="col">Situação</th>
+   <th scope="col">Comentário</th>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-with-statement', 'with statement')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-with-statement', 'with statement')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES5.1', '#sec-12.10', 'with statement')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Agora proibido no modo estrito.</td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES3', '#sec-12.10', 'with statement')}}</td>
+   <td>{{Spec2('ES3')}}</td>
+   <td> </td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES1', '#sec-12.10', 'with statement')}}</td>
+   <td>{{Spec2('ES1')}}</td>
+   <td>Definição inicial</td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
+
+<p>{{CompatibilityTable}}</p>
+
+<div id="compat-desktop">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Chrome</th>
+   <th>Edge</th>
+   <th>Firefox (Gecko)</th>
+   <th>Internet Explorer</th>
+   <th>Opera</th>
+   <th>Safari</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<div id="compat-mobile">
+<table class="compat-table">
+ <tbody>
+  <tr>
+   <th>Feature</th>
+   <th>Android</th>
+   <th>Chrome for Android</th>
+   <th>Edge</th>
+   <th>Firefox Mobile (Gecko)</th>
+   <th>IE Mobile</th>
+   <th>Opera Mobile</th>
+   <th>Safari Mobile</th>
+  </tr>
+  <tr>
+   <td>Basic support</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+   <td>{{CompatVersionUnknown}}</td>
+  </tr>
+ </tbody>
+</table>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("Statements/block", "block")}}</li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Functions_and_function_scope/Strict_mode">Strict mode</a></li>
+ <li>{{jsxref("Symbol.unscopables")}}</li>
+ <li>{{jsxref("Array.@@unscopables", "Array.prototype[@@unscopables]")}}</li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/strict_mode/index.html b/files/pt-br/web/javascript/reference/strict_mode/index.html
new file mode 100644
index 0000000000..52e0b4aa79
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/strict_mode/index.html
@@ -0,0 +1,355 @@
+---
+title: Strict mode
+slug: Web/JavaScript/Reference/Strict_mode
+translation_of: Web/JavaScript/Reference/Strict_mode
+---
+<div>{{JsSidebar("More")}}</div>
+
+<p>O <strong>strict mode</strong> do <a class="external" href="http://www.ecma-international.org/publications/standards/Ecma-262.htm">ECMAScript 5</a> é uma forma de <em>optar</em> por uma variante restrita do JavaScript. O strict mode não é apenas um subconjunto: ele <em>intencionalmente</em> tem semânticas diferentes do código normal. Navegadores que não suportam strict mode executarão código strict mode com um comportamento diferente dos navegadores que suportam, então não confie no strict mode sem testar o suporte a funcionalidades dos aspectos relevantes do strict mode. Código strict mode e código não-strict mode podem coexistir, então scripts podem optar pelo strict mode incrementalmente.</p>
+
+<p>O strict mode faz várias mudanças nas semânticas normais do JavaScript. Primeiro, o strict mode elimina alguns erros silenciosos do JavaScript fazendo-os lançar exceções. Segundo, o strict mode evita equívocos que dificultam que motores JavaScript realizem otimizações: código strict mode pode às vezes ser feito para executar mais rápido que código idêntico não-strict mode. Terceiro, strict mode proíbe algumas sintaxes que provavelmente serão definidas em versões futuras do ECMAScript.</p>
+
+<p>Veja <a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode/Transitioning_to_strict_mode">transitioning to strict mode</a> se você quer mudar seu código para funcionar na variante restrita do JavaScript.</p>
+
+<h2 id="Invocando_strict_mode">Invocando strict mode</h2>
+
+<p>Strict mode se aplica a <em>scripts </em>inteiros ou <em>funções individuais</em>. Ele não se aplica a declarações de bloco fechadas em chaves <code>{}</code>; tentar aplicá-lo a tais contextos não faz nada. Código <code>eval</code>, código <code>Function</code>, atributos <em>event handlers</em>, strings passadas para <code><a href="/pt-BR/docs/Web/API/WindowTimers.setTimeout" title="en-US/DOM/window.setTimeout">setTimeout</a></code> e coisas do tipo são scripts inteiros, e invocar strict mode neles funciona como esperado.</p>
+
+<h3 id="Strict_mode_para_scripts">Strict mode para scripts</h3>
+
+<p>Para invocar strict mode para um script inteiro, coloque <em>exatamente</em> a declaração <code>"use strict";</code> (ou <code>'use strict';</code>) antes de qualquer outra declaração.</p>
+
+<pre class="brush: js">// Sintaxe strict mode para todo o script
+"use strict";
+var v = "Oi! Eu sou um script strict mode!";
+</pre>
+
+<p>Essa sintaxe tem uma armadilha que <a class="link-https" href="https://bugzilla.mozilla.org/show_bug.cgi?id=579119">já pegou</a> <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=627531">um site grande</a>: não é possível concatenar cegamente scripts não-conflitantes. Considere concatenar um script strict mode com um script não-strict mode: a concatenação inteira parece strict! O inverso também é verdade: não-strict mais strict parece não-strict. Concatenar scripts strict mode com outros é bom, e concatenar scripts não-strict mode é bom. Simplesmente concatenar scripts strict e não-strict é problemático. Portanto é recomendado que você ative strict mode função-por-função (pelo menos durante o período de transição).</p>
+
+<p>Você também pode usar a abordagem de embrulhar o conteúdo inteiro de um script em uma função e fazer a função externa usar strict mode. Isto elimina o problema da concatenação, mas significa que você tem que exportar explicitamente quaisquer variáveis globais fora do escopo da função.</p>
+
+<h3 id="Strict_mode_para_funções">Strict mode para funções</h3>
+
+<p>Da mesma forma, para invocar strict mode para uma função, coloque <em>exatamente</em> a declaração <code>"use strict";</code> (ou <code>'use strict';</code>) no corpo da função antes de qualquer outra declaração.</p>
+
+<pre class="brush: js">function strict(){
+  // Sintaxe strict mode a nível de função
+  'use strict';
+  function nested() { return "E eu também!"; }
+  return "Oi! Eu sou uma função strict mode!  " + nested();
+}
+function notStrict() { return "Eu não sou strict."; }
+</pre>
+
+<h2 id="Mudanças_no_strict_mode">Mudanças no strict mode</h2>
+
+<p>Strict mode muda tanto a sintaxe quando o comportamento em tempo de execução. Mudanças geralmente se encaixam em uma destas categorias: mudanças que convertem equívocos em erros (como erros de sintaxe ou em tempo de execução), mudanças que simplificam como uma variável particular para um dado uso de um nome é computada, mudanças que simplificam <code>eval</code> e <code>arguments</code>, mudanças que facilitam JavaScript "seguro", e mudanças que antecipam a evolução futura do ECMAScript.</p>
+
+<h3 id="Convertendo_equívocos_em_erros">Convertendo equívocos em erros</h3>
+
+<p>Strict mode transforma em erros alguns equívocos anteriormente aceitos. O JavaScript foi projetado para ser fácil para novos desenvolvedores, e algumas vezes ele dá semânticas de não-erros a operações que deveriam ser erros. Algumas vezes isso resolve o problema pontual, mas outras vezes cria problemas piores no futuro. Strict mode trata esses equívocos como erros para que sejam descobertos e consertados prontamente.</p>
+
+<p>Primeiro, o strict mode impossibilita criar variáveis globais acidentalmente. Em JavaScript normal, cometer um erro de digitação ao digitar uma variável em uma atribuição cria uma nova propriedade no objeto global e continua a "funcionar" (embora falhas futuras sejam possíveis: provavelmente, em JavaScript moderno). Atribuições que acidentalmente criariam variáveis globais lançam exceções em vez disso no strict mode:</p>
+
+<pre class="brush: js">"use strict";
+                     // Assumindo que uma variável global variavelErrada existe
+variavellErrada = 17; // esta linha lança ReferenceError por conta do
+                     // erro de digitação da variável
+</pre>
+
+<p>Segundo, strict mode faz com que atribuições que outrora falhariam silenciosamente lançar uma exceção. Por exemplo, <code>NaN</code> é uma variável global não-atribuível. Em código normal, atribuir a <code>NaN</code> não faz nada; o desenvolvedor não recebe qualquer resposta de falha. No strict mode, atribuir a <code>NaN</code> lança uma exceção. Qualquer atribuição que falha silenciosamente em código normal (atribuir a uma propriedade não-atribuível, atribuir a uma propriedade getter-only, atribuir a uma propriedade de um objeto <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/preventExtensions">não-extensível</a>) lançarão exceções em strict mode:</p>
+
+<pre class="brush: js">"use strict";
+
+// Atribuir a uma propriedade não-atribuível
+var obj1 = {};
+Object.defineProperty(obj1, "x", { value: 42, writable: false });
+obj1.x = 9; // lança TypeError
+
+// Atribuir a uma propriedade getter-only
+var obj2 = { get x() { return 17; } };
+obj2.x = 5; // lança TypeError
+
+// Atribuir a uma nova propriedade de um objeto não-extensível
+var fixed = {};
+Object.preventExtensions(fixed);
+fixed.newProp = "ohai"; // lança TypeError
+</pre>
+
+<p>Terceiro, strict mode faz com que tentativas de deletar propriedades não-deletáveis lancem exceções (onde anteriormente a tentativa simplesmente não faria efeito):</p>
+
+<pre class="brush: js">"use strict";
+delete Object.prototype; // lança TypeError
+</pre>
+
+<p>Quarto, strict mode anterior ao Gecko 34 requer que todas as propriedades nomeadas em um objeto literal sejam únicas. Código normal pode duplicar nomes de propriedades, sendo que a última ocorrência determina o valor da propriedade. Mas como apenas o último faz algo, a duplicação é meramente um vetor de bugs, se o código for modificado para mudar o valor da propriedade por outro meio que não modificando a última instância. Nomes de propriedades duplicados são erro de sintaxe em strict mode:</p>
+
+<div class="note">
+<p>Não é mais o caso no ECMAScript 6 ({{bug(1041128)}}).</p>
+</div>
+
+<pre class="brush: js">"use strict";
+var o = { p: 1, p: 2 }; // !!! erro de sintaxe
+</pre>
+
+<p>Quinto, strict mode exige que nomes de parâmetros de função sejam únicos. Em código normal, o último argumento duplicado esconde argumentos anteriores com nome semelhante. Estes argumentos anteriores continuam disponíveis através de <code>arguments[i]</code><strong>,</strong> portanto não são completamente inacessíveis. Entretanto, esta ocultação faz pouco sentido e provavelmente é indesejável (pode esconder um erro de digitação, por exemplo), então em strict mode nomes de argumentos duplicados são erro de sintaxe:</p>
+
+<pre class="brush: js">function sum(a, a, c){ // !!! erro de sintaxe
+  "use strict";
+  return a + b + c; // errado se este código executasse
+}
+</pre>
+
+<p>Sexto, strict mode em ECMAScript 5 proíbe sintaxe octal. Sintaxe ocatal não é parte do ECMAScript 5, mas é suportado em todos os navegadores prefixando o número octal com um zero: <code>0644 === 420</code> e <code>"\045" === "%"</code>. No ECMAScript 6, número octal é suportado prefixando um número com "<code>0o</code>": </p>
+
+<pre class="brush: js">var a = 0o10; // ES6: Octal</pre>
+
+<p>Novos desenvolvedores algumas vezes acham que um prefixo zero não tem significado semântico, então eles o utilizam como mecanismo de alinhamento — mas isso muda o significado do número! Sintaxe octal é raramente útil e pode ser usada equivocadamente, então o strict mode torna octal erro de sintaxe:</p>
+
+<pre class="brush: js">"use strict";
+var sum = 015 + // !!! erro de sintaxe
+          197 +
+          142;
+</pre>
+
+<p>Sétimo, strict mode em ECMAScript 6 proíbe definir propriedades em valores {{Glossary("Primitivo", "primitivos")}}. Sem strict mode, definir uma propriedade é simplesmente ignorado; com strict mode, no entanto, um {{jsxref("TypeError")}} é lançado.</p>
+
+<pre class="brush: js">(function() {
+"use strict";
+
+false.true = "";             // TypeError
+(14).navegandoPara = "casa"; // TypeError
+"com".voce = "distante";     // TypeError
+
+})();</pre>
+
+<h3 id="Simplificando_usos_de_variáveis">Simplificando usos de variáveis</h3>
+
+<p>Strict mode simplifica como nomes de variáveis se mapeiam a definições de variáveis particulares no código. Muitas otimizações de compiladores dependem da habilidade de dizer que variável <em>X</em> está guardada <em>naquele</em> local; isto é crítico para otimizar completamente o código JavaScript. JavaScript às vezes torna este mapeamento básico de nome para definição de variável no código impossível de executar até o tempo de execução. Strict mode remove a maioria dos casos onde isso acontece, então o compilador pode otimizar melhor código strict mode.</p>
+
+<p>Primeiro, strict mode proíbe <code>with</code>. O problema com <code>with</code> é que qualquer nome dentro do block pode mapear tanto para uma propriedade do objeto passado quanto para uma variável no escopo envolvente (ou até global), em tempo de execução: é impossível saber qual de antemão. Strict mode torna <code>with</code> um erro de sintaxe, então não há chance de um nome em um <code>with</code> referir-re a uma localização deconhecida em tempo de execução:</p>
+
+<pre class="brush: js">"use strict";
+var x = 17;
+with (obj) // !!! erro de sintaxe
+{
+  // Se isto não fosse strict mode, isso seria var x ou obj.x?
+  // No geral, é impossível saber sem executar o código, então
+  // o nome não pode ser otimizado.
+  x;
+}
+</pre>
+
+<p>A alternativa simples de atribuir o objeto a uma variável de nome curto, e então acessar a propriedade correspondente naquela variável, está pronta para substituir <code>with</code>.</p>
+
+<p>Segundo, <a href="http://whereswalden.com/2011/01/10/new-es5-strict-mode-support-new-vars-created-by-strict-mode-eval-code-are-local-to-that-code-only/">eval de código strict mode não introduz novas variáves no escopo envolvente</a>. Em código normal, <code>eval("var x;")</code> introduz uma variável <code>x</code> na função envolvente ou no escopo global. Isto significa que, no geral, em uma função que contém uma chamada para <code>eval</code>, todo nome que não se refere a um argumento ou variável local deve ser mapeado para uma definição particular em tempo de execução (porque aquele <code>eval</code> pode ter introduzido uma nova variável que esconderia a variável externa). No strict mode, <code>eval</code> cria variáveis apenas para o código sendo avaliado, portanto <code>eval</code> não pode afetar se um nome se refere a uma variável externa ou alguma variável local:</p>
+
+<pre class="brush: js">var x = 17;
+var evalX = eval("'use strict'; var x = 42; x");
+console.assert(x === 17);
+console.assert(evalX === 42);
+</pre>
+
+<p>Relacionadamente, se a função <code>eval</code> for invocada por uma expressão da forma <code>eval(...)</code> em código strict mode, o código será avaliado como código strict mode. O código pode invocar strict code explicitamente, mas não é necessário.</p>
+
+<pre class="brush: js">function strict1(str){
+  "use strict";
+  return eval(str); // str será tratado como código strict mode
+}
+function strict2(f, str){
+  "use strict";
+  return f(str); // não é eval(...): str é strict se e
+                 // somente se invocar strict mode
+}
+function nonstrict(str){
+  return eval(str); // str é strict se e somente se
+                    // invocar strict mode
+}
+
+strict1("'Código strict mode!'");
+strict1("'use strict'; 'Código strict mode!'");
+strict2(eval, "'Código não-strict.'");
+strict2(eval, "'use strict'; 'Código strict mode!'");
+nonstrict("'Código não-strict.'");
+nonstrict("'use strict'; 'Código strict mode!'");
+</pre>
+
+<p>Portanto nomes em código <code>eval</code> de strict mode se comportam da mesma forma que nomes em código strict mode que não estão sendo avaliados como resultado de <code>eval</code>.</p>
+
+<p>Terceiro, strict mode proíbe deletar nomes simples. <code>delete name</code> em strict mode é erro de sintaxe:</p>
+
+<pre class="brush: js">"use strict";
+
+var x;
+delete x; // !!! erro de sintaxe
+
+eval("var y; delete y;"); // !!! erro de sintaxe</pre>
+
+<h3 id="Tornando_eval_e_arguments_mais_simples">Tornando <code>eval</code> e <code>arguments</code> mais simples</h3>
+
+<p>Strict mode torna <code>arguments</code> e <code>eval</code> menos estranhamente mágicos. Ambos envolvem uma quantidade considerável de comportamento mágico em código normal: <code>eval</code> para adicionar ou remover <em>bindings</em> e para mudar valores de <em>bindings</em>, e <code>arguments</code> com suas propriedades indexadas como <em>alias</em> de argumentos nomeados. Strict mode dá grandes passos na direção de tratar <code>eval</code> e <code>arguments</code> como palavras-chave, embora reparos completos não venham até uma futura edição do ECMAScript.</p>
+
+<p>Primeiro, os nomes <code>eval</code> e <code>arguments</code> não podem ser vinculados ou atribuídos na sintaxe da linguagem. Todas as tentativas são erros de sintaxe:</p>
+
+<pre class="brush: js">"use strict";
+eval = 17;
+arguments++;
+++eval;
+var obj = { set p(arguments) { } };
+var eval;
+try { } catch (arguments) { }
+function x(eval) { }
+function arguments() { }
+var y = function eval() { };
+var f = new Function("arguments", "'use strict'; return 17;");
+</pre>
+
+<p>Segundo, código strict mode não faz <em>alias</em> para propriedades de objetos <code>arguments</code> criados dentro de si. Em código normal dentro de uma função cujo primeiro argumento é <code>arg</code>, definir <code>arg</code> também define <code>arguments[0]</code>, e vice-versa (a menos que nenhum argumento seja fornecido ou <code>arguments[0]</code> seja deletado). Objetos <code>arguments</code> para funções strict mode armazenam os argumentos originais quando a função é invocada. <code>arguments[i]</code> não rastreia o valor do argumento nomeado correspondente, nem um argumento nomeado rastreia o valor do <code>arguments[i]</code> correspondente.</p>
+
+<pre class="brush: js">function f(a){
+  "use strict";
+  a = 42;
+  return [a, arguments[0]];
+}
+var pair = f(17);
+console.assert(pair[0] === 42);
+console.assert(pair[1] === 17);
+</pre>
+
+<p>Terceiro, <code>arguments.callee</code> não é mais suportado. Em código normal, <code>arguments.callee</code> se refere à função envolvente. Esse caso de uso é frágil: apenas nomeie a função envolvente! Além disso, <code>arguments.callee</code> prejudica substancialmente otimizações como tornar funções <em>inline</em> porque deve ser possível fornecer uma referência à função não-<em>inline</em> se <code>arguments.callee</code> for acessado. <code>arguments.callee</code> para funções strict mode é uma propriedade não-deletável que lança exceção quando atribuída ou recuperada:</p>
+
+<pre class="brush: js">"use strict";
+var f = function() { return arguments.callee; };
+f(); // lança TypeError
+</pre>
+
+<h3 id="Tornando_JavaScript_seguro">Tornando JavaScript "seguro"</h3>
+
+<p>Strict mode torna mais fácil escrever JavaScript "seguro". Alguns websites agora oferecem formas de escrever JavaScript que será executado pelo website <em>em nome de outros usuários</em>. JavaScript nos navegadores pode acessar informações privadas do usuário, então tal JavaScript deve ser parcialmente transformado antes de executado, para barrar acesso a funcionalidades proibidas. A flexibilidade do JavaScript torna isso efetivamente impossível sem várias verificações em tempo de execução. Algumas funções da linguagem são tão pervasivas que fazer verificações em tempo de execução tem um custo de desempenho considerável. Alguns ajustes do strict mode, mais a exigência de que o JavaScript submetido por usuários seja código strict mode e invocá-lo de uma certa maneira, reduz substancialmente a necessidade de realizar verificações em tempo de execução.</p>
+
+<p>Primeiro, o valor passado como <code>this</code> para uma função em strict mode não é forçado a ser um objeto (entenda-se "encaixotamento"). Para uma função normal, <code>this</code> é sempre um objeto: seja o objeto fornecido se chamado com um <code>this</code> cujo valor é um objeto; o valor, encaixotado, se chamado com um <code>this</code> Boolean, string ou número; ou o objeto global se chamado com um <code>this</code> <code>undefined</code> ou <code>null</code>. Use <a href="/en-US/Web/JavaScript/Reference/Global_Objects/Function/call" title="en-US/JavaScript/Reference/Global_Objects/Function/call"><code>call</code></a>, <a href="/en-US/Web/JavaScript/Reference/Global_Objects/Function/apply" title="en-US/JavaScript/Reference/Global_Objects/Function/apply"><code>apply</code></a>, ou <code><a href="/en-US/Web/JavaScript/Reference/Global_Objects/Function/bind" title="en-US/JavaScript/Reference/Global_Objects/Function/bind">bind</a></code> para especificar um determinado <code>this</code>. O encaixotamento automático não apenas é um custo de desempenho, como também expor o objeto global em navegadores é um risco de segurança, porque o objeto global oferece acesso a funcionalidades que ambientes JavaScript "seguros" devem restringir. Assim, para uma função strict mode, o <code>this</code> especificado não é encaixotado em um objeto, e se não especificado, <code>this</code> será <code>undefined</code>:</p>
+
+<pre class="brush: js">"use strict";
+function fun() { return this; }
+console.assert(fun() === undefined);
+console.assert(fun.call(2) === 2);
+console.assert(fun.apply(null) === null);
+console.assert(fun.call(undefined) === undefined);
+console.assert(fun.bind(true)() === true);
+</pre>
+
+<p>Isso significa, além de outras coisas, que em navegadores não é mais possíveis referenciar o objeto <code>window</code> através de <code>this</code> dentro de uma função strict mode.</p>
+
+<p>Segundo, em strict mode não é mais possível "caminhar" a pilha JavaScript via extensões do ECMAScript comumente implementadas. Em código normal com essas extensões, quando uma funçao <code>fun</code> está no meio de ser chamada, <code>fun.caller</code> é a função que chamou <code>fun</code> mais recentemente, e <code>fun.arguments</code> é o <code>arguments</code> para aquela invocação de <code>fun</code>. Ambas as extensões são problemáticas para JavaScript "seguro" porque permitem que código "seguro" acesse funções "privilegiadas" e seus argumentos (potencialmente inseguros). Se <code>fun</code> estiver em strict mode, tanto <code>fun.caller</code> quando <code>fun.arguments</code> são propriedades não-deletáveis que lançam exceção quando definidas ou recuperadas:</p>
+
+<pre class="brush: js">function restrita()
+{
+  "use strict";
+  restrita.caller;    // lança TypeError
+  restrita.arguments; // lança TypeError
+}
+function invocadorPrivilegiado()
+{
+  return restrita();
+}
+invocadorPrivilegiado();
+</pre>
+
+<p>Terceiro, <code>arguments</code> para funções strict mode não oferecem mais acesso às variáveis da chamada de função correspondente. Em algumas implementações antigas do ECMAScript, <code>arguments.caller</code> era um objeto cujas propriedades faziam <em>alias</em> de variáveis naquela função. Isso é um <a href="http://stuff.mit.edu/iap/2008/facebook/">risco de segurança</a> porque quebra a habilidade de esconder valores privilegiados via abstração de função; isso também exclui a maioria das otimizações. Por essas razões, nenhum navegador moderno implementa isso. Ainda assim, por causa de sua funcionalidade histórica, <code>arguments.caller</code> para uma função strict mode também é uma propriedade não-deletável que lança exceção quando definida ou recuperada:</p>
+
+<pre class="brush: js">"use strict";
+function fun(a, b)
+{
+  "use strict";
+  var v = 12;
+  return arguments.caller; // lança TypeError
+}
+fun(1, 2); // não expõe v (or a or b)
+</pre>
+
+<h3 id="Pavimentando_o_caminho_para_versões_futuras_do_ECMAScript">Pavimentando o caminho para versões futuras do ECMAScript</h3>
+
+<p>Versões futuras do ECMAScript provavelmente introduzirão nova sintaxe, e o strict mode no ECMAScript 5 aplica algumas restrições para facilitar essa transição. Será mais fácil fazer algumas mudanças se as fundações dessas mudanças forem proibidas no strict mode.</p>
+
+<p>Primeiro, no strict mode, uma pequena lista de identificadores tornam-se palavras-chave reservadas. Estas palavras são <code>implements</code>, <code>interface</code>, <code>let</code>, <code>package</code>, <code>private</code>, <code>protected</code>, <code>public</code>, <code>static</code> e <code>yield</code>. Em strict mode, portanto, você não pode nomear ou usar variáveis ou argumentos com esses nomes.</p>
+
+<pre class="brush: js">function package(protected){ // !!!
+  "use strict";
+  var implements; // !!!
+
+  interface: // !!!
+  while (true){
+    break interface; // !!!
+  }
+
+  function private() { } // !!!
+}
+function fun(static) { 'use strict'; } // !!!
+
+</pre>
+
+<p>Duas ressalvas específicas à Mozilla: primeiro, se seu código for JavaScript 1.7 ou superior (por exemplo em código chrome ou usando o <code>&lt;script type=""&gt;</code> correto) e for strict mode, <code>let</code> e <code>yield</code> têm a funcionaldade que eles tiveram desde que essas palavras-chave foram introduzidas pela primeira vez. Mas código strict mode na web, carregado com <code>&lt;script src=""&gt;</code> ou <code>&lt;script&gt;...&lt;/script&gt;</code>, não serão capazes de usar <code>let</code>/<code>yield</code> como identificadores. Segundo, enquanto o ES5 reserva incondicionalmente as palavras <code>class</code>, <code>enum</code>, <code>export</code>, <code>extends</code>, <code>import</code> e <code>super</code>, a Mozilla reservava-as apenas em strict mode antes do Firefox 5.</p>
+
+<p>Segundo, <a href="http://whereswalden.com/2011/01/24/new-es5-strict-mode-requirement-function-statements-not-at-top-level-of-a-program-or-function-are-prohibited/">strict mode proíbe declaração de funções fora do nível superior de um script ou função</a>. Em código normal em navegadores, declarações de funções são permitidas "em todo lugar". <em>Isso não é parte do ES5 (nem do ES3)!</em> É uma extensão com semânticas incompatíveis em diferentes navegadores. Edições futuras do ECMAScript promissoramente especificarão novas semânticas para declarações de funções fora do nível superior de um script ou função. <a href="http://wiki.ecmascript.org/doku.php?id=conventions:no_non_standard_strict_decls">Proibir tais declarações de funções em strict mode</a> "limpa a mesa" para especificação em uma <em>release</em> futura do ECMAScript:</p>
+
+<pre class="brush: js">"use strict";
+if (true){
+  function f() { } // !!! erro de sintaxe
+  f();
+}
+
+for (var i = 0; i &lt; 5; i++){
+  function f2() { } // !!! erro de sintaxe
+  f2();
+}
+
+function baz(){ // correto
+  function eit() { } // erro de sintaxe
+}
+</pre>
+
+<p>Essa proibição não é adequada ao strict mode porque tais declarações de função são uma extensão de ES5 básico. Mas é a recomendação do comitê do ECMAScript e os navegadores a implementarão.</p>
+
+<h2 id="Strict_mode_em_navegadores">Strict mode em navegadores</h2>
+
+<p>Os principais navegadores agora implementam strict mode. Entretanto, não dependa deles cegamente já que ainda há <a href="http://caniuse.com/use-strict">várias versões de navegadores utilizadas por aí que têm apenas suporte parcial ao strict mode</a> ou que não suportam de forma alguma (ex.: Internet Explorer abaixo da versão 10!). <em>Strict mode muda semântica</em>. Depender dessas mudanças causará equívocos e erros em navegadores que não implementam strict mode. Tenha cautela ao usar strict mode e gere confiança no strict mode com testes de funcionalidades que verificam se partes relevantes do strict mode estão implementadas. Finalmente, certifique-se de <em>testar seu código em navegadores que suportam e não suportam strict mode. </em>Se você testar apenas em navegadores que não suportam strict mode, você provavelmente terá problemas em navegadores que suportam e vice-versa.</p>
+
+<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('ES5.1', '#sec-10.1.1', 'Strict Mode Code')}}</td>
+   <td>{{Spec2('ES5.1')}}</td>
+   <td>Definição inicial. Veja também: <a href="http://www.ecma-international.org/ecma-262/5.1/#sec-C">Strict mode restriction and exceptions</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ES6', '#sec-strict-mode-code', 'Strict Mode Code')}}</td>
+   <td>{{Spec2('ES6')}}</td>
+   <td><a href="http://www.ecma-international.org/ecma-262/6.0/#sec-strict-mode-of-ecmascript">Strict mode restriction and exceptions</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-strict-mode-code', 'Strict Mode Code')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td><a href="https://tc39.github.io/ecma262/#sec-strict-mode-of-ecmascript">Strict mode restriction and exceptions</a></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li><a class="external" href="http://whereswalden.com/2010/09/08/new-es5-strict-mode-support-now-with-poison-pills/" title="http://whereswalden.com/2010/09/08/new-es5-strict-mode-support-now-with-poison-pills/">Where's Walden? » New ES5 strict mode support: now with poison pills!</a></li>
+ <li><a class="external" href="http://whereswalden.com/2011/01/24/new-es5-strict-mode-requirement-function-statements-not-at-top-level-of-a-program-or-function-are-prohibited/" title="http://whereswalden.com/2011/01/24/new-es5-strict-mode-requirement-function-statements-not-at-top-level-of-a-program-or-function-are-prohibited/">Where's Walden? » New ES5 strict mode requirement: function statements not at top level of a program or function are prohibited</a></li>
+ <li><a class="external" href="http://whereswalden.com/2011/01/10/new-es5-strict-mode-support-new-vars-created-by-strict-mode-eval-code-are-local-to-that-code-only/" title="http://whereswalden.com/2011/01/10/new-es5-strict-mode-support-new-vars-created-by-strict-mode-eval-code-are-local-to-that-code-only/">Where's Walden? » New ES5 strict mode support: new vars created by strict mode eval code are local to that code only</a></li>
+ <li><a href="http://qnimate.com/javascript-strict-mode-in-nutshell/">JavaScript "use strict" tutorial for beginners.</a></li>
+ <li><a class="external" href="http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/" title="http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/">John Resig - ECMAScript 5 Strict Mode, JSON, and More</a></li>
+ <li><a class="external" href="http://dmitrysoshnikov.com/ecmascript/es5-chapter-2-strict-mode/">ECMA-262-5 in detail. Chapter 2. Strict Mode.</a></li>
+ <li><a class="external" href="http://kangax.github.io/compat-table/es5/#Strict_mode">Strict mode compatibility table</a></li>
+ <li><a href="/en-US/docs/Web/JavaScript/Reference/Strict_mode/Transitioning_to_strict_mode">Transitioning to strict mode</a></li>
+</ul>
diff --git a/files/pt-br/web/javascript/reference/template_strings/index.html b/files/pt-br/web/javascript/reference/template_strings/index.html
new file mode 100644
index 0000000000..e2a11abfa4
--- /dev/null
+++ b/files/pt-br/web/javascript/reference/template_strings/index.html
@@ -0,0 +1,140 @@
+---
+title: Template strings
+slug: Web/JavaScript/Reference/template_strings
+translation_of: Web/JavaScript/Reference/Template_literals
+---
+<div>{{JsSidebar("More")}}</div>
+
+<p><em>Template </em><span style="color: #57606f;">Strings</span> são <em>string</em>s que permitem expressões embutidas. Você pode <em>utilizar string</em> multi-linhas e interpolação de <em>string </em>com elas.</p>
+
+<p>Basicamente é uma nova forma de criar strings e tornar o seu código um pouco mais legível.</p>
+
+<h2 id="Syntax" name="Syntax">Sintaxe</h2>
+
+<pre class="syntaxbox notranslate">`corpo de texto`
+
+`texto linha 1
+ texto linha 2`
+
+`texto string ${expression} texto string`
+
+tag `texto string ${expression} texto string`
+</pre>
+
+<h2 id="Descrição">Descrição</h2>
+
+<p><em>Template strings</em> são envolvidas por (<a href="https://pt.wikipedia.org/wiki/Acento_grave">acentos graves</a>) (` `) em vez de aspas simples ou duplas. <em>Template strings</em> podem possuir <em>placeholders</em>. Estes são indicados por um cifrão seguido de chaves (<code>${expression}</code>). As expressões nos <em>placeholders</em>, bem como o texto em volta delas são passados a uma função. A função padrão apenas concatena as partes em uma <em>string</em> única. Se existir uma expressão precedendo a <em>template string</em> (função <code>tag</code> exemplo), a <em>template string </em>é definida como "<em>tagged template string</em>". No caso, a expressão <em>tag</em> (geralmente uma função) é chamada pela <em>template string</em> processada, que você pode manipular antes de produzir o resultado.</p>
+
+<pre class="brush: js notranslate">`\`` === '`' // --&gt; true</pre>
+
+<h3 id="Strings_multi-linhas">Strings multi-linhas</h3>
+
+<p>Qualquer caracter de nova linha inserido no código é parte da <em>template string</em>. Utilizando <em>strings</em> normais, você teria de usar a síntaxe a seguir para obter strings multi-linhas:</p>
+
+<pre class="brush: js notranslate">console.log('texto string linha 1\n' +
+'texto string linha 2');
+// "texto string linha 1
+// texto string linha 2"</pre>
+
+<p>Para obter o mesmo efeito com strings multi-linhas, você agora pode escrever:</p>
+
+<pre class="brush: js notranslate">console.log(`texto string linha 1
+texto string linha 2`);
+// "texto string linha 1
+//  texto string linha 2"</pre>
+
+<h3 id="Interpolação_de_Expressões">Interpolação de Expressões</h3>
+
+<p>Para encapsular expressões dentro de strings, você precisava utilizar a seguinte sintaxe:</p>
+
+<pre class="brush: js notranslate">var a = 5;
+var b = 10;
+console.log('Quinze é ' + (a + b) + ' e\nnão ' + (2 * a + b) + '.');
+// "Quinze é 15 e
+// não 20."</pre>
+
+<p>Agora, com template strings, você pode utilizar as substituições sintáticas tornando o código mais legível:</p>
+
+<pre class="brush: js notranslate">var a = 5;
+var b = 10;
+console.log(`Quinze é ${a + b} e
+não ${2 * a + b}.`);
+// "Quinze é 15 e
+// não 20."</pre>
+
+<h3 id="Tagged_template_strings">Tagged template strings</h3>
+
+<p>Uma forma mais avançada dos <em>template string</em> são os <em>template strings</em> com marcações ou tags, ou <em>tagged template strings</em>. Com eles, você tem a possibilidade de modificar a saída dos <em>template strings</em> usando uma função. O primeiro argumento contém um array de literais ("Hello" e "World" neste exemplo). Do segundo em diante e cada argumento subsequente contém valores previamente processados (algumas vezes chamados <em>cooked</em>) pelas expressões de substituição ("15" e "50" no caso do exemplo). No final, a função retorna a string ja manipulada:</p>
+
+<pre class="brush: js notranslate">var a = 5;
+var b = 10;
+
+function tag(strings, ...values) {
+  console.log(strings[0]); // "Hello "
+  console.log(strings[1]); // " world"
+  console.log(values[0]);  // 15
+  console.log(values[1]);  // 50
+
+  return "Bazinga!";
+}
+
+tag`Hello ${ a + b } world ${ a * b}`;
+// "Bazinga!"
+</pre>
+
+<h3 id="Strings_Raw">Strings <em>Raw</em></h3>
+
+<p>A propriedade especial <code>raw</code>, disponível no primeiro argumento da função da <em>tagged template string</em> acima, permite o acesso as strings de maneira pura (<em>raw</em>) exatamente como elas foram especificadas:</p>
+
+<pre class="brush: js notranslate">function tag(strings, ...values) {
+  return strings.raw[0];
+}
+
+tag`string text line 1 \n string text line 2`;
+// "string text line 1 \\n string text line 2"
+</pre>
+
+<p>Adicionalmente, o método {{jsxref("String.raw()")}} permite a criação de strings cruas, exatamente como as <em>template functions</em> e as concatenações deveram criar.</p>
+
+<pre class="brush: js notranslate">String.raw`Hi\n${2+3}!`; // "Hi\\n5!"</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('ES2015', '#sec-template-literals', 'Template Literals')}}</td>
+   <td>{{Spec2('ES2015')}}</td>
+   <td>Definição inicial. Definido em várias seções da especificação: <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-template-literals">Template Literals</a>, <a href="http://www.ecma-international.org/ecma-262/6.0/#sec-tagged-templates">Tagged Templates</a></td>
+  </tr>
+  <tr>
+   <td>{{SpecName('ESDraft', '#sec-template-literals', 'Template Literals')}}</td>
+   <td>{{Spec2('ESDraft')}}</td>
+   <td>Definido em várias seções da especificação: <a href="https://tc39.github.io/ecma262/#sec-template-literals">Template Literals</a>, <a href="https://tc39.github.io/ecma262/#sec-tagged-templates">Tagged Templates</a></td>
+  </tr>
+ </tbody>
+</table>
+
+<h2 id="Compatibidade_com_navegadores">Compatibidade com navegadores</h2>
+
+<div>
+<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se você deseja contribuir com os dados, confira <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e nos envie um pull request.</div>
+
+<p>{{Compat("javascript.grammar.template_literals")}}</p>
+</div>
+
+<h2 id="Veja_também">Veja também</h2>
+
+<ul>
+ <li>{{jsxref("String")}}</li>
+ <li>{{jsxref("String.raw()")}}</li>
+ <li><a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar">Gramática léxica</a></li>
+ <li><a href="https://gist.github.com/WebReflection/8f227532143e63649804">Template-like strings in ES3 compatible syntax</a></li>
+ <li><a href="https://hacks.mozilla.org/2015/05/es6-in-depth-template-strings-2/">"ES6 in Depth: Template strings" on hacks.mozilla.org</a></li>
+ <li><a href="https://styled-components.com/">https://styled-components.com/</a></li>
+</ul>