unslug pt-br: move

16 files changed, 0 insertions, 1520 deletions

diff --git a/files/pt-br/web/javascript/guide/closures/index.html b/files/pt-br/web/javascript/guide/closures/index.html
deleted file mode 100644
index efc7578d7d..0000000000
--- a/files/pt-br/web/javascript/guide/closures/index.html
+++ /dev/null
@@ -1,336 +0,0 @@
----
-title: Closures
-slug: Web/JavaScript/Guide/Closures
-tags:
-  - Closure
-  - ES5
-  - Intermediário
-  - JavaScript
-  - Referencia
-translation_of: Web/JavaScript/Closures
----
-<div>{{jsSidebar("Intermediate")}}</div>
-
-<p class="summary">Um <em>closure </em>(fechamento) é uma função que se "lembra" do ambiente — ou escopo léxico — em que ela foi criada.</p>
-
-<h2 id="Escopo_léxico">Escopo léxico</h2>
-
-<p>Considere a função abaixo:</p>
-
-<div style="width: auto; overflow: hidden;">
-<pre class="brush: js">function init() {
-  var name = "Mozilla";
-  function displayName() {
-    alert(name);
-  }
-  displayName();
-}
-init();
-</pre>
-</div>
-
-<p>A função <code>init()</code> cria uma variável local chamada <code>name</code>, e depois define uma função chamada <code>displayName()</code>. <code>displayName()</code> é uma função aninhada (um <em>closure</em>) — ela é definida dentro da função <code>init()</code>, e está disponivel apenas dentro do corpo daquela função. Diferente de <span style="font-family: courier new,andale mono,monospace; line-height: 1.5;">init()</span><span style="line-height: 1.5;">,</span><span style="line-height: 1.5;"> </span><code style="font-style: normal; line-height: 1.5;">displayName()</code><span style="line-height: 1.5;"> não tem variáveis locais próprias, e ao invés disso reusa a variável </span><code style="font-style: normal; line-height: 1.5;">name</code><span style="line-height: 1.5;"> declarada na função pai.</span></p>
-
-<p><a href="http://jsfiddle.net/xAFs9/3/">Rode</a> o código e veja que isso funciona. Este é um exemplo de <em>escopo léxico:</em> em JavaScript, o escopo de uma variável é definido por sua localização dentro do código fonte (isto é aparentemente <em>léxico</em>) e funções aninhadas têm acesso às variáveis declaradas em seu escopo externo.</p>
-
-<h2 id="Closure">Closure</h2>
-
-<p>Agora considere o seguinte exemplo:</p>
-
-<pre class="brush: js">function makeFunc() {
-  var name = "Mozilla";
-  function displayName() {
-    alert(name);
-  }
-  return displayName;
-}
-
-var myFunc = makeFunc();
-myFunc();
-</pre>
-
-<p>Se você rodar este código o mesmo terá exatamente o mesmo efeito que o <code>init()</code> do exemplo anterior: a palavra "Mozilla" será mostrada na caixa de alerta. O que é diferente - e interessante - é o fato de que a função interna do <code>displayName()</code> foi retornada da função externa antes de ser executada.</p>
-
-<p>Pode parecer não muito intuitivo de que o código de fato funciona. Normalmente variáveis locais a uma função apenas existem pela duração da execução da mesma. Uma vez que <code>makeFunc()</code> terminou de executar, é razoável esperar que a variável <code>name</code> não será mais necessária. Dado que o código ainda funciona como o esperado, este não é o caso.</p>
-
-<p>A solução para tal problema é que a função <code>myFunc</code> tornou-se uma <code>closure</code>. Uma closure (fechamento) trata-se de um tipo especial de objeto que combina duas coisas: a função e o ambiente onde a função foi criada. Este ambiente consiste de quaisquer variáveis que estavam no escopo naquele momento em que a função foi criada. Neste caso, <code>myFunc</code> é a closure que incorpora tanto a função <code>displayName</code> quanto a palavra <em>Mozilla</em> que existia quando a closure foi criada.</p>
-
-<p>Aqui temos um exemplo um pouco mais interessante, a função <code>makeAdder</code>:</p>
-
-<pre class="brush: js">function makeAdder(x) {
-  return function(y) {
-    return x + y;
-  };
-}
-
-var add5 = makeAdder(5);
-var add10 = makeAdder(10);
-
-print(add5(2));  // 7
-print(add10(2)); // 12
-</pre>
-
-<p>Neste exemplo definimos a função <code>makeAdder(x)</code> que toma um único argumento <code>x</code> e retorna uma nova função. A função retornada toma então um único argumento, <code>y</code>, e retorna então a soma de <code>x</code> e de <code>y</code>.</p>
-
-<p>Na essência o <code>makeAdder</code> trata-se de uma <em>função fábrica - </em>irá construir outras funções que podem adicionar um determinado valor específico a seu argumento. No exemplo acima usamos a fábrica de funções para criar duas novas funções - uma que adiciona 5 ao argumento, e outra que adiciona 10.</p>
-
-<p>Ambas as funções <code>add5</code> e <code>add10</code><em> </em><code> </code>são closures. Compartilham o mesmo corpo de definição de função mas armazenam diferentes ambientes. No ambiente da <code>add5</code>, por exemplo, <code>x</code> equivale a 5, enquanto na <code>add10</code> o valor de x é 10.</p>
-
-<h2 id="Closures_na_prática">Closures na prática</h2>
-
-<p>Esta é a teoria — mas closures são realmente úteis? Vamos considerar suas aplicações práticas. Uma closure deixa você associar dados (do ambiente) com uma função que trabalha estes dados. Isto está diretamente ligado com programação orientada a objetos, onde objetos nos permitem associar dados (as propriedades do objeto) utilizando um ou mais métodos.</p>
-
-<p>Consequentemente, você pode utilizar uma closure em qualquer lugar onde você normalmente utilizaria um objeto de único método.</p>
-
-<p>Situações onde você poderia utilizar isto são comuns em ambientes web. Muitos códigos escritos em JavaScript para web são baseados em eventos - nós definimos algum comportamento e então, o atribuimos a um evento que será disparado pelo usuário (quando uma tecla for pressionada, por exemplo). Nosso código normalmente é utilizado como callback: uma função que será executada como resposta ao evento.</p>
-
-<p>Aqui temos um exemplo prático: suponha que queremos adicionar alguns botões para ajustar o tamanho do texto de uma página. Um jeito de fazer seria especificar o tamanho da fonte no elemento body e então definir o tamanho dos outros elementos da página (os cabeçalhos, por exemplo) utilizando a unidade relativa em:</p>
-
-<pre class="brush: css">body {
-  font-family: Helvetica, Arial, sans-serif;
-  font-size: 12px;
-}
-
-h1 {
-  font-size: 1.5em;
-}
-h2 {
-  font-size: 1.2em;
-}
-</pre>
-
-<p>Nossos botões interativos de tamanho de texto podem alterar a propriedade font-size do elemento body, e os ajustes serão refletidos em outros elementos graças à unidade relativa.</p>
-
-<p>O código JavaScript:</p>
-
-<pre class="brush: js">function makeSizer(size) {
-  return function() {
-    document.body.style.fontSize = size + 'px';
-  };
-}
-
-var size12 = makeSizer(12);
-var size14 = makeSizer(14);
-var size16 = makeSizer(16);
-</pre>
-
-<p><code>size12</code>, <code>size14</code> e <code>size16</code> agora são funções que devem redimensionar o texto do elemento body para 12, 14 e 16 pixels respectivamente. Nós podemos designá-las a botões (neste caso, links) como feito a seguir:</p>
-
-<pre class="brush: js">document.getElementById('size-12').onclick = size12;
-document.getElementById('size-14').onclick = size14;
-document.getElementById('size-16').onclick = size16;
-</pre>
-
-<pre class="brush: html">&lt;a href="#" id="size-12"&gt;12&lt;/a&gt;
-&lt;a href="#" id="size-14"&gt;14&lt;/a&gt;
-&lt;a href="#" id="size-16"&gt;16&lt;/a&gt;
-</pre>
-
-<p><a href="https://jsfiddle.net/vnkuZ">View on JSFiddle</a></p>
-
-<h2 id="Emulando_métodos_privados_com_closures">Emulando métodos privados com closures</h2>
-
-<p>Linguagens como Java oferecem a habilidade de declarar métodos privados, o que significa que eles só poderão ser chamados por outros métodos na mesma classe.</p>
-
-<p>O JavaScript não oferece uma maneira nativa de fazer isso, mas é possível emular métodos privados usando closures. Métodos privados não são somente úteis para restringir acesso ao código: eles também oferecem uma maneira eficaz de gerenciar seu namespace global, evitando que métodos não essenciais baguncem a interface pública do seu código.</p>
-
-<p>Veja como definir algumas funções públicas que acessam funções e variáveis privadas, usando closures que também é conhecido como <a class="external" href="http://www.google.com/search?q=javascript+module+pattern" title="http://www.google.com/search?q=javascript+module+pattern">module pattern</a>:</p>
-
-<pre class="brush: js">var Counter = (function() {
-  var privateCounter = 0;
-  function changeBy(val) {
-    privateCounter += val;
-  }
-  return {
-    increment: function() {
-      changeBy(1);
-    },
-    decrement: function() {
-      changeBy(-1);
-    },
-    value: function() {
-      return privateCounter;
-    }
-  }
-})();
-
-alert(Counter.value()); /* Alerts 0 */
-Counter.increment();
-Counter.increment();
-alert(Counter.value()); /* Alerts 2 */
-Counter.decrement();
-alert(Counter.value()); /* Alerts 1 */
-</pre>
-
-<p>Tem muita coisa acontecendo aqui. Nos exemplos anteriores cada closure teve o seu próprio ambiente; aqui nós criamos um ambiente único que é compartilhado por três funções: <code>Counter.increment</code>, <code>Counter.decrement</code> e <code>Counter.value</code>.</p>
-
-<p>O ambiente compartilhado é criado no corpo de uma função anônima, da qual é executada assim que é definida. O ambiente contém dois itens privados: uma variável chamada <code>privateCounter</code> e uma função chamada <code>changeBy</code>. Nenhum desses itens privados podem ser acessados diretamente de fora da função anônima. Ao invés disso, eles devem ser acessados pelas três funções públicas que são retornadas.</p>
-
-<p>Aquelas três funções públicas são closures que compartilham o mesmo ambiente. Graças ao escopo léxico do JavaScript, cada uma delas tem acesso a variável <code>privateCounter</code> e à função <code>changeBy</code>.</p>
-
-<div class="blockIndicator note">
-<p>Você perceberá que estamos definindo uma função anônima que cria um contador , e então o executamos imediatamente e atribuímos o resultado à variável <code>Counter</code>. Poderíamos armazenar essa função em uma variável separada e usá-la para criar diversos contadores.</p>
-</div>
-
-<pre class="brush: js">var makeCounter = function() {
-  var privateCounter = 0;
-  function changeBy(val) {
-    privateCounter += val;
-  }
-  return {
-    increment: function() {
-      changeBy(1);
-    },
-    decrement: function() {
-      changeBy(-1);
-    },
-    value: function() {
-      return privateCounter;
-    }
-  }
-};
-
-var Counter1 = makeCounter();
-var Counter2 = makeCounter();
-alert(Counter1.value()); /* Alerts 0 */
-Counter1.increment();
-Counter1.increment();
-alert(Counter1.value()); /* Alerts 2 */
-Counter1.decrement();
-alert(Counter1.value()); /* Alerts 1 */
-alert(Counter2.value()); /* Alerts 0 */
-</pre>
-
-<p>Observe como cada um dos contadores mantém a sua independência em relação ao outro. Seu ambiente durante a execução da função <code>makeCounter()</code> é diferente a cada vez que ocorre. A variável <code>privateCounter</code> contém uma instância diferente a cada vez.</p>
-
-<div class="blockIndicator note">
-<p>Usar closures desta maneira oferece uma série de benefícios que estão normalmente associados a programação orientada a objetos, em particular encapsulamento e ocultação de dados.</p>
-</div>
-
-<dl>
-</dl>
-
-<h2 id="Criando_closures_dentro_de_loops_Um_erro_comum">Criando closures dentro de loops: Um erro comum</h2>
-
-<p>Antes da introdução da palavra chave <a href="/en-US/docs/JavaScript/Reference/Statements/let" title="let"><code>let</code></a> no JavaScript 1.7, um problema comum ocorria com closures quando eram criadas dentro de um loop. Considere o exemplo:</p>
-
-<pre class="brush: html">&lt;p id="help"&gt;Helpful notes will appear here&lt;/p&gt;
-&lt;p&gt;E-mail: &lt;input type="text" id="email" name="email"&gt;&lt;/p&gt;
-&lt;p&gt;Name: &lt;input type="text" id="name" name="name"&gt;&lt;/p&gt;
-&lt;p&gt;Age: &lt;input type="text" id="age" name="age"&gt;&lt;/p&gt;
-</pre>
-
-<pre class="brush: js">function showHelp(help) {
-  document.getElementById('help').innerHTML = help;
-}
-
-function setupHelp() {
-  var helpText = [
-      {'id': 'email', 'help': 'Your e-mail address'},
-      {'id': 'name', 'help': 'Your full name'},
-      {'id': 'age', 'help': 'Your age (you must be over 16)'}
-    ];
-
-  for (var i = 0; i &lt; helpText.length; i++) {
-    var item = helpText[i];
-    document.getElementById(item.id).onfocus = function() {
-      showHelp(item.help);
-    }
-  }
-}
-
-setupHelp();
-</pre>
-
-<p><a href="https://jsfiddle.net/v7gjv">View on JSFiddle</a></p>
-
-<p>O array <code>helpText</code> define três dicas úteis, cada uma associada ao ID de um input no documento. O loop percorre essas definições, atrelando um evento onfocus para cada um que mostra o método de ajuda associado.</p>
-
-<p>Se você tentar executar esse código, Você verá que não vai funcionar como esperado. Não importa em qual campo ocorre o focus, a mensagem sobre a sua idade será mostrada.</p>
-
-<p>O motivo disto é que as funções atreladas ao onfocus são closures; elas consistem na definição da função e do ambiente capturado do escopo da função <code>setupHelp</code>. Três closures foram criados, mas todos eles compartilham o mesmo ambiente. No momento em que os callbacks do onfocus são executados, o loop segue seu curso e então a variável item (compartilhada por todos os três closures) fica apontando para a última entrada na lista <code>helpText</code>.</p>
-
-<p>Uma solução seria neste caso usar mais closures: em particular, usar uma fábrica de funções como descrito anteriormente:</p>
-
-<pre class="brush: js">function showHelp(help) {
-  document.getElementById('help').innerHTML = help;
-}
-
-function makeHelpCallback(help) {
-  return function() {
-    showHelp(help);
-  };
-}
-
-function setupHelp() {
-  var helpText = [
-      {'id': 'email', 'help': 'Your e-mail address'},
-      {'id': 'name', 'help': 'Your full name'},
-      {'id': 'age', 'help': 'Your age (you must be over 16)'}
-    ];
-
-  for (var i = 0; i &lt; helpText.length; i++) {
-    var item = helpText[i];
-    document.getElementById(item.id).onfocus = makeHelpCallback(item.help);
-  }
-}
-
-setupHelp();
-</pre>
-
-<p><a href="https://jsfiddle.net/v7gjv/1">View on JSFiddle</a></p>
-
-<p>Isto funciona conforme o esperado. Ao invés dos callbacks compartilharem o mesmo ambiente, a função <code>makeHelpCallback</code> cria um novo ambiente para cada um no qual <code>help</code> se refere à string correspondente do array <code>helpText</code>.</p>
-
-<h2 id="Considerações_de_performance">Considerações de performance</h2>
-
-<p>Não é sábio criar funções dentro de outras funções se o closure não for necessário para uma tarefa em particular, pois ele afetará a performance do script de forma bem negativa tanto em velocidade de processamento quanto em consumo de memória.</p>
-
-<p>Por exemplo, ao criar uma nova classe/objeto, os métodos devem normalmente estar associados ao protótipo do objeto do que definido no construtor. O motivo disso é que sempre que o construtor for chamado os métodos serão reatribuídos (isto é, para cada criação de objeto).</p>
-
-<p>Considere o seguinte exemplo pouco prático porém demonstrativo:</p>
-
-<pre class="brush: js">function MyObject(name, message) {
-  this.name = name.toString();
-  this.message = message.toString();
-  this.getName = function() {
-    return this.name;
-  };
-
-  this.getMessage = function() {
-    return this.message;
-  };
-}
-</pre>
-
-<p>O código anterior não aproveita os benefícios dos closures e portanto poderia ser reformulado assim:</p>
-
-<pre class="brush: js">function MyObject(name, message) {
-  this.name = name.toString();
-  this.message = message.toString();
-}
-MyObject.prototype = {
-  getName: function() {
-    return this.name;
-  },
-  getMessage: function() {
-    return this.message;
-  }
-};
-</pre>
-
-<p>Ou assim:</p>
-
-<pre class="brush: js">function MyObject(name, message) {
-  this.name = name.toString();
-  this.message = message.toString();
-}
-MyObject.prototype.getName = function() {
-  return this.name;
-};
-MyObject.prototype.getMessage = function() {
-  return this.message;
-};
-</pre>
-
-<p>Nos dois exemplos anteriores, o protótipo herdado pode ser compartilhado por todos os objetos, e as definições de métodos não precisam ocorrer sempre que o objeto for criado. Veja <a href="/en-US/docs/JavaScript/Guide/Details_of_the_Object_Model" title="Detalhes do modelo de objeto">Detalhes do modelo de objeto</a> para mais detalhes.</p>
diff --git a/files/pt-br/web/javascript/guide/coleções_chaveadas/index.html b/files/pt-br/web/javascript/guide/coleções_chaveadas/index.html
deleted file mode 100644
index cb626865f8..0000000000
--- a/files/pt-br/web/javascript/guide/coleções_chaveadas/index.html
+++ /dev/null
@@ -1,149 +0,0 @@
----
-title: Coleções chaveadas
-slug: Web/JavaScript/Guide/Coleções_chaveadas
-tags:
-  - Coleções
-  - Guía
-  - JavaScript
-  - Mapas
----
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Indexed_Collections", "Web/JavaScript/Guide/Working_with_Objects")}}</div>
-
-<p class="summary">This chapter introduces collections of data which are ordered by a key; Map and Set objects contain elements which are iterable in the order of insertion.</p>
-
-<h2 id="Maps">Maps</h2>
-
-<h3 id="Map_object"><code>Map</code> object</h3>
-
-<p>ECMAScript 6 introduces a new data structure to map values to values. A {{jsxref("Map")}} object is a simple key/value map and can iterate its elements in insertion order</p>
-
-<p>The following code shows some basic operations with a <code>Map</code>. See also the {{jsxref("Map")}} reference page for more examples and the complete API. You can use a {{jsxref("Statements/for...of","for...of")}} loop to return an array of <code>[key, value]</code> for each iteration.</p>
-
-<pre class="brush: js">var sayings = new Map();
-sayings.set("dog", "woof");
-sayings.set("cat", "meow");
-sayings.set("elephant", "toot");
-sayings.size; // 3
-sayings.get("fox"); // undefined
-sayings.has("bird"); // false
-sayings.delete("dog");
-
-for (var [key, value] of sayings) {
-  console.log(key + " goes " + value);
-}
-// "cat goes meow"
-// "elephant goes toot"
-</pre>
-
-<h3 id="Object_and_Map_compared"><code>Object</code> and <code>Map</code> compared</h3>
-
-<p>Traditionally, {{jsxref("Object", "objects", "", 1)}} have been used to map strings to values. Objects allow you to set keys to values, retrieve those values, delete keys, and detect whether something is stored at a key. <code>Map</code> objects, however, have a few more advantages that make them better maps.</p>
-
-<ul>
- <li>The keys of an <code>Object</code> are {{jsxref("Global_Objects/String","Strings")}}, where they can be of any value for a <code>Map</code>.</li>
- <li>You can get the size of a <code>Map</code> easily while you have to manually keep track of size for an <code>Object</code>.</li>
- <li>The iteration of maps is in insertion order of the elements.</li>
- <li>An <code>Object</code> has a prototype, so there are default keys in the map. (this can be bypassed using <code>map = Object.create(null)</code>).</li>
-</ul>
-
-<p>These two tips can help you to decide whether to use a <code>Map</code> or an <code>Object</code>:</p>
-
-<ul>
- <li>Use maps over objects when keys are unknown until run time, and when all keys are the same type and all values are the same type.</li>
- <li>Use objects when there is logic that operates on individual elements.</li>
-</ul>
-
-<h3 id="WeakMap_object"><code>WeakMap</code> object</h3>
-
-<p>The {{jsxref("WeakMap")}} object is a collection of key/value pairs in which the <strong>keys are objects only</strong> and the values can be arbitrary values. The object references in the keys are held <em>weakly</em> meaning that they are target of garbage collection (GC) if there is no other reference to the object anymore. The <code>WeakMap</code> API is the same as the <code>Map</code> API.</p>
-
-<p>One difference to <code>Map</code> objects is that <code>WeakMap</code> keys are not enumerable (i.e. there is no method giving you a list of the keys). If they were, the list would depend on the state of garbage collection, introducing non-determinism.</p>
-
-<p>For more information and example code, see also "Why <em>Weak</em>Map?" on the {{jsxref("WeakMap")}} reference page.</p>
-
-<p>One use case of <code>WeakMap</code> objects is to store private data for an object or to hide implementation details. The following example is from Nick Fitzgerald blog post <a href="http://fitzgeraldnick.com/weblog/53/">"Hiding Implementation Details with ECMAScript 6 WeakMaps"</a>. The private data and methods belong inside the object and are stored in the <code>privates</code> WeakMap object. Everything exposed on the instance and prototype is public; everything else is inaccessible from the outside world because <code>privates</code> is not exported from the module</p>
-
-<pre class="brush: js">const privates = new WeakMap();
-
-function Public() {
-  const me = {
-    // Private data goes here
-  };
-  privates.set(this, me);
-}
-
-Public.prototype.method = function () {
-  const me = privates.get(this);
-  // Do stuff with private data in `me`...
-};
-
-module.exports = Public;
-</pre>
-
-<h2 id="Sets">Sets</h2>
-
-<h3 id="Set_object"><code>Set</code> object</h3>
-
-<p>{{jsxref("Set")}} objects are collections of values. You can iterate its elements in insertion order. A value in a <code>Set</code> may only occur once; it is unique in the <code>Set</code>'s collection.</p>
-
-<p>The following code shows some basic operations with a <code>Set</code>. See also the {{jsxref("Set")}} reference page for more examples and the complete API.</p>
-
-<pre class="brush: js">var mySet = new Set();
-mySet.add(1);
-mySet.add("some text");
-mySet.add("foo");
-
-mySet.has(1); // true
-mySet.delete("foo");
-mySet.size; // 2
-
-for (let item of mySet) console.log(item);
-// 1
-// "some text"
-</pre>
-
-<h3 id="Converting_between_Array_and_Set">Converting between Array and Set</h3>
-
-<p>You can create an {{jsxref("Array")}} from a Set using {{jsxref("Array.from")}} or the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Spread_operator">spread operator</a>. Also, the <code>Set</code> constructor accepts an <code>Array</code> to convert in the other direction. Note again that <code>Set</code> objects store unique values, so any duplicate elements from an Array are deleted when converting.</p>
-
-<pre class="brush: js">Array.from(mySet);
-[...mySet2];
-
-mySet2 = new Set([1,2,3,4]);
-</pre>
-
-<h3 id="Array_and_Set_compared"><code>Array</code> and <code>Set</code> compared</h3>
-
-<p>Traditionally, a set of elements has been stored in arrays in JavaScript in a lot of situations. The new <code>Set</code> object, however, has some advantages:</p>
-
-<ul>
- <li>Checking whether an element exists in an collection using {{jsxref("Array.indexOf", "indexOf")}} for arrays is slow.</li>
- <li><code>Set</code> objects let you delete elements by their value. With an array you would have to splice based on a element's index.</li>
- <li>The value {{jsxref("NaN")}} can not be found with <code>indexOf</code> in array.</li>
- <li><code>Set</code> objects store unique values, you don't have to keep track of duplicates by yourself.</li>
-</ul>
-
-<h3 id="WeakSet_object"><code>WeakSet</code> object</h3>
-
-<p>{{jsxref("WeakSet")}} objects are collections of objects. An object in the <code>WeakSet</code> may only occur once; it is unique in the <code>WeakSet</code>'s collection and objects are not enumerable.</p>
-
-<p>The main differences to the {{jsxref("Set")}} object are:</p>
-
-<ul>
- <li>In contrast to <code>Sets</code>, <code>WeakSets</code> are <strong>collections of objects only</strong> and not of arbitrary values of any type.</li>
- <li>The <code>WeakSet</code> is <em>weak</em>: References to objects in the collection are held weakly. If there is no other reference to an object stored in the <code>WeakSet</code>, they can be garbage collected. That also means that there is no list of current objects stored in the collection. <code>WeakSets</code> are not enumerable.</li>
-</ul>
-
-<p>The use cases of <code>WeakSet</code> objects are limited. They will not leak memory so it can be safe to use DOM elements as a key and mark them for tracking purposes, for example.</p>
-
-<h2 id="Key_and_value_equality_of_Map_and_Set">Key and value equality of <code>Map</code> and <code>Set</code></h2>
-
-<p>Both, the key equality of <code>Map</code> objects and the value equality of <code>Set</code> objects, are based on the "<a href="https://people.mozilla.org/~jorendorff/es6-draft.html#sec-samevaluezero">same-value-zero algorithm</a>":</p>
-
-<ul>
- <li>Equality works like the identity comparison operator <code>===</code>.</li>
- <li><code>-0</code> and <code>+0</code> are considered equal.</li>
- <li>{{jsxref("NaN")}} is considered equal to itself (contrary to <code>===</code>).</li>
-</ul>
-
-<p>{{PreviousNext("Web/JavaScript/Guide/Indexed_Collections", "Web/JavaScript/Guide/Working_with_Objects")}}</p>
diff --git a/files/pt-br/web/javascript/guide/declarações/index.html b/files/pt-br/web/javascript/guide/control_flow_and_error_handling/index.html
index e352b58f6d..e352b58f6d 100644
--- a/files/pt-br/web/javascript/guide/declarações/index.html
+++ b/files/pt-br/web/javascript/guide/control_flow_and_error_handling/index.html
diff --git a/files/pt-br/web/javascript/guide/detalhes_do_modelo_do_objeto/index.html b/files/pt-br/web/javascript/guide/details_of_the_object_model/index.html
index 55a4c928a5..55a4c928a5 100644
--- a/files/pt-br/web/javascript/guide/detalhes_do_modelo_do_objeto/index.html
+++ b/files/pt-br/web/javascript/guide/details_of_the_object_model/index.html
diff --git a/files/pt-br/web/javascript/guide/funções/index.html b/files/pt-br/web/javascript/guide/functions/index.html
index 7077d1787b..7077d1787b 100644
--- a/files/pt-br/web/javascript/guide/funções/index.html
+++ b/files/pt-br/web/javascript/guide/functions/index.html
diff --git a/files/pt-br/web/javascript/guide/values,_variables,_and_literals/index.html b/files/pt-br/web/javascript/guide/grammar_and_types/index.html
index 7920ee6b1a..7920ee6b1a 100644
--- a/files/pt-br/web/javascript/guide/values,_variables,_and_literals/index.html
+++ b/files/pt-br/web/javascript/guide/grammar_and_types/index.html
diff --git a/files/pt-br/web/javascript/guide/igualdade/index.html b/files/pt-br/web/javascript/guide/igualdade/index.html
deleted file mode 100644
index 57f1c2fdcc..0000000000
--- a/files/pt-br/web/javascript/guide/igualdade/index.html
+++ /dev/null
@@ -1,259 +0,0 @@
----
-title: Igualdade em JavaScript
-slug: Web/JavaScript/Guide/Igualdade
-translation_of: Web/JavaScript/Equality_comparisons_and_sameness
-translation_of_original: Web/JavaScript/Guide/Sameness
----
-<p>A ES6 possui três facilidades internas para determinar se algum <var>x</var> e algum <var>y</var> são "os mesmos". Elas são: igualdade ou "igual duplo" (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators" title="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators"><code>==</code></a>), igualdade rigorosa ou "igual triplo" (<a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators" title="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators"><code>===</code></a>), e <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a>. (Note que <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> foi adicionado na ES6. Ambos igual duplo e igual triplo existiam antes da ES6, e seu comportamento permanece o mesmo.)</p>
-<h2 id="Visão_geral">Visão geral</h2>
-<p>Para demonstração, aqui estão as três comparações de igualdade em uso:</p>
-<pre class="brush:js">x == y</pre>
-<pre class="brush:js">x === y</pre>
-<pre class="brush:js">Object.is(x, y)</pre>
-<p>De modo breve, o operador igual duplo irá realizar uma conversão de tipo na hora de  comparar duas coisas; o operador igual triplo fará a mesma comparação sem conversão de tipo (simplesmente sempre retornando <code>false</code> se os tipos forem diferentes); e <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> se comportará da mesma forma que o operador igual triplo, mas lidando de forma especial com <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a> e <code>-0</code> e <code>+0</code> de modo que os dois últimos não são considerados os mesmos, enquanto que <code>Object.is(NaN, NaN)</code> será <code>true</code>. (Comparar <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a> com <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a> geralmente—i.e., usando-se o operador igual duplo ou o operador igual triplo—resulta em <code>false</code>, de acordo com a IEEE 754.)</p>
-<p>Note que a distinção entre todas essas formas de comparação tem a ver com a forma com que lidam com primitivos; nenhuma delas compara se os parâmetros são conceitualmente similares em estrutura. Para quaisquer objetos não-primitivos <var>x</var> e <var>y</var> que têm a mesma estrutura mas que são objetos distintos, todas as formas de comparação acima resultarão no valor <code>false</code>.</p>
-<p>Por exemplo:</p>
-<pre class="brush:js">let x = { value: 17 };
-let y = { value: 17 };
-console.log(Object.is(x, y)); // false;
-console.log(x === y);         // false
-console.log(x == y);          // false</pre>
-<h2 id="Igualdade_abstrata_igualdade_rigorosa_e_mesmo_valor">Igualdade abstrata, igualdade rigorosa, e mesmo valor</h2>
-<p>Na ES5, a comparação realizada por <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators" title="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators"><code>==</code></a> é descrita na <a href="http://ecma-international.org/ecma-262/5.1/#sec-11.9.3" title="http://ecma-international.org/ecma-262/5.1/#sec-11.9.3">Seção 11.9.3, O Algoritmo de Igualdade Abstrata</a>. A comparação <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators" title="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators"><code>===</code></a> é descrita em <a href="http://ecma-international.org/ecma-262/5.1/#sec-11.9.6" title="http://ecma-international.org/ecma-262/5.1/#sec-11.9.6">11.9.6, O Algoritmo de Igualdade Rigorosa</a>. (Dê uma olhada nestes. Eles são rápidos e legíveis. Dica: leia o algoritmo de igualdade rigorosa primeiro.) A ES5 também descreve, na <a href="http://ecma-international.org/ecma-262/5.1/#sec-9.12" title="http://ecma-international.org/ecma-262/5.1/#sec-9.12">Seção 9.12, O Algoritmo de MesmoValor</a> para ser usado internamente pelo engine JS. Ele é em sua maioria similar ao Algoritmo de Igualdade Rigorosa, com exceção de que 11.9.6.4 e 9.12.4 diferem na forma de lidar com <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number"><code>Number</code></a>s (números). A ES6 simplesmente propõe expôr esse algoritmo através de <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a>.</p>
-<p>Podemos ver que com os operadores igual duplo e igual triplo, com a exceção de fazer uma checagem de tipo de início em 11.9.6.1, o Algoritmo de Igualdade Rigorosa é um subconjunto do Algoritmo de Igualdade Abstrata, pois 11.9.6.2–7 corresponde a 11.9.3.1.a–f.</p>
-<h2 id="Um_modelo_para_entender_comparações_de_igualdade">Um modelo para entender comparações de igualdade?</h2>
-<p>Antes da ES6, você pode ter dito, a respeito dos operadores igual duplo e igual triplo, que um é uma versão "melhorada" do outro. Por exemplo, alguém poderia dizer que o operador igual duplo é uma versão extendidad do operador igual triplo, pois o primeiro faz tudo que o último faz, com conversão de tipo em seus operandos (por exemplo, de modo que <code>6 == "6"</code>). Alternativamente, alguém poderia dizer que o operador igual triplo é uma versão melhorada do operador igual duplo, pois requer que os dois operandos sejam do mesmo tipo. Qual é melhor depende de qual é a sua idéia de patamar.</p>
-<p>No entanto, essa forma de pensar sobre os operados de igualdade internos não é um modelo que pode ser "esticado" para permitir um lugar para o <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> da ES6 nesse "espectro". O <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> não é simplesmente "menos restrito" do que o operador igual duplo ou "mais restrito" do que o operador igual triplo, nem cabe em algum lugar entre esses níveis (isto é, sendo mais restrito que o operador igual duplo, mas menos restrito que o operador igual triplo). Nós podemos ver da tabela de comparações de igualdade abaixo que isto é devido à forma com que <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> lida com <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a>. Perceba que se <code>Object.is(NaN, NaN)</code> resultasse no valor <code>false</code>, nós <em>poderíamos</em> dizer que ele cabe no espectro pouco restrito/restrito como uma forma ainda mais restrita do operador igual triplo, uma que faz distinção entre <code>-0</code> e <code>+0</code>. A forma de lidar com <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a> significa que isso não é verdade, no entanto. Infelizmente, <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> simplesmente deve ser considerado em termos de duas características específicas, ao invés de sua rigorosidade (ou falta da mesma) com respeito aos operadores de igualdade.</p>
-<table class="standard-table">
-  <caption>
-    Comparações de Igualdade</caption>
-  <thead>
-    <tr>
-      <th scope="col" style="text-align: center;">x</th>
-      <th scope="col" style="text-align: center;">y</th>
-      <th scope="col" style="width: 10em; text-align: center;"><code>==</code></th>
-      <th scope="col" style="width: 10em; text-align: center;"><code>===</code></th>
-      <th scope="col" style="width: 10em; text-align: center;"><code>Object.is</code></th>
-    </tr>
-  </thead>
-  <tbody>
-    <tr>
-      <td><code>undefined</code></td>
-      <td><code>undefined</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-    </tr>
-    <tr>
-      <td><code>null</code></td>
-      <td><code>null</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-    </tr>
-    <tr>
-      <td><code>true</code></td>
-      <td><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-    </tr>
-    <tr>
-      <td><code>false</code></td>
-      <td><code>false</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-    </tr>
-    <tr>
-      <td><code>"foo"</code></td>
-      <td><code>"foo"</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-    </tr>
-    <tr>
-      <td><code>{ foo: "bar" }</code></td>
-      <td><code>x</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-    </tr>
-    <tr>
-      <td><code>0</code></td>
-      <td><code>0</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-    </tr>
-    <tr>
-      <td><code>+0</code></td>
-      <td><code>-0</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>0</code></td>
-      <td><code>false</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>""</code></td>
-      <td><code>false</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>""</code></td>
-      <td><code>0</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>"0"</code></td>
-      <td><code>0</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>"17"</code></td>
-      <td><code>17</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>new String("foo")</code></td>
-      <td><code>"foo"</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>null</code></td>
-      <td><code>undefined</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>null</code></td>
-      <td><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>undefined</code></td>
-      <td><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>{ foo: "bar" }</code></td>
-      <td><code>{ foo: "bar" }</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>new String("foo")</code></td>
-      <td><code>new String("foo")</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>0</code></td>
-      <td><code>null</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>0</code></td>
-      <td><code>NaN</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>"foo"</code></td>
-      <td><code>NaN</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-    </tr>
-    <tr>
-      <td><code>NaN</code></td>
-      <td><code>NaN</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(255, 144, 144); text-align: center;"><code>false</code></td>
-      <td style="background-color: rgb(144, 255, 144); text-align: center;"><code>true</code></td>
-    </tr>
-  </tbody>
-</table>
-<h2 id="Quando_usar_Object.is_versus_o_operador_igual_triplo">Quando usar <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> versus o operador igual triplo</h2>
-<p>Além da forma com que trata o valor it <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a>, de modo geral, o único caso em o comportamento especial de <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> com a relação a zeros é capaz de ser de interesse é na busca de certos esquemas de metaprogramação, especialmente em relação a descritores de propriedade quando é desejável que seu trabalho espelhe algumas das características de <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty"><code>Object.defineProperty</code></a>. Se seu caso de uso não requer isso, sugere-se evitar-se <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> e usar-se o operador <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators" title="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators"><code>===</code></a> ao invés disso. Mesmo se seus requerimentos envolvem que comparações entre dois valores <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a> resultem em <code>true</code>, de modo geral é mais fácil fazer-se uma checagem especial por <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/NaN"><code>NaN</code></a>s (usando-se o método <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/isNaN" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN"><code>isNaN</code></a> disponíveis de versões anteritores da ECMAScript) do que lidar com como computações externas possam afetar o sinal de quaisquer zeros que você possa encontrar em sua comparação.</p>
-<p>Aqui está uma lista não-exaustiva de métodos e operadores internos que podem fazer com que uma distinção entre <code>-0</code> e <code>+0</code> se manifeste em seu código:</p>
-<dl>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#-_.28Unary_Negation.29" title="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators"><code>- (negação unária)</code></a></dt>
-</dl>
-<dl>
-  <dd>
-    <p>É óbvio que negar <code>0</code> produz <code>-0</code>. Mas a abstração de uma expressão pode fazer com o valor <code>-0</code> apareça de modo despercebido. Por exemplo, considere o seguinte:</p>
-    <pre class="brush:js">let stoppingForce = obj.mass * -obj.velocity</pre>
-    <p>Se <code>obj.velocity</code> é <code>0</code> (ou resulta no valor <code>0</code>), um <code>-0</code> é introduzido naquele ponto e propaga-se para <code>stoppingForce</code>.</p>
-  </dd>
-</dl>
-<dl>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/atan2"><code>Math.atan2</code></a></dt>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/ceil"><code>Math.ceil</code></a></dt>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow"><code>Math.pow</code></a></dt>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/round"><code>Math.round</code></a></dt>
-</dl>
-<dl>
-  <dd>
-    É possível que um <code>-0</code> seja introduzido em uma expressão como um valor de retorno desses métodos em alguns casos, mesmo quando nenhum <code>-0</code> existe como um dos parâmetros. Por exemplo, usando-se <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/pow"><code>Math.pow</code></a> para elevar o valor <code>-<a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Infinity">Infinity</a></code> à potência de qualquer expoente negativo ímpar resulta no valor <code>-0</code>. Veja a documentação para os métodos individuais.</dd>
-</dl>
-<dl>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/floor"><code>Math.floor</code></a></dt>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/max"><code>Math.max</code></a></dt>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/min"><code>Math.min</code></a></dt>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sin"><code>Math.sin</code></a></dt>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/sqrt"><code>Math.sqrt</code></a></dt>
-  <dt>
-    <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tan" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/tan"><code>Math.tan</code></a></dt>
-</dl>
-<dl>
-  <dd>
-    É possível obter-se um valor de retorno <code>-0</code> desses métodos em alguns casos quando um <code>-0</code> existe como um dos parâmetros. Por exemplo, <code>Math.min(-0, +0)</code> resulta no valor <code>-0</code>. Veja a documentação para os métodos individuais.</dd>
-</dl>
-<dl>
-  <dt>
-    <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">~</a></code></dt>
-  <dt>
-    <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">&lt;&lt;</a></code></dt>
-  <dt>
-    <code><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators" title="/en-US/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators">&gt;&gt;</a></code></dt>
-  <dd>
-    Cada um desses operadores usa o algoritmo ToInt32 internamente. Uma vez que só há uma representação para o valor 0 no tipo inteiro de 32 bits interno, o valor <code>-0</code> não irá sobreviver a um arredondamento depois de uma operação inversa. Por exemplo, ambos <code>Object.is(~~(-0), -0)</code> e <code>Object.is(-0 &lt;&lt; 2 &gt;&gt; 2, -0)</code> resultam no valor <code>false</code>.</dd>
-</dl>
-<p>Contar com <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is"><code>Object.is</code></a> quando o sinal de zeros não é levado em consideração pode ser problemático. É claro que quando a intenção é distinguir entre <code>-0</code> e <code>+0</code>, ele faz exatamente o que é desejado.gual</p>
diff --git a/files/pt-br/web/javascript/guide/inheritance_and_the_prototype_chain/index.html b/files/pt-br/web/javascript/guide/inheritance_and_the_prototype_chain/index.html
deleted file mode 100644
index d6aad53066..0000000000
--- a/files/pt-br/web/javascript/guide/inheritance_and_the_prototype_chain/index.html
+++ /dev/null
@@ -1,193 +0,0 @@
----
-title: Herança e cadeia de protótipos (prototype chain)
-slug: Web/JavaScript/Guide/Inheritance_and_the_prototype_chain
-tags:
-  - herança intermediário JavaScript OOP
-translation_of: Web/JavaScript/Inheritance_and_the_prototype_chain
----
-<div>{{jsSidebar("Advanced")}}</div>
-
-<p>JavaScript é um pouco confuso para desenvolvedores com experiência em linguagens baseadas em classes (como Java ou C++), porque é dinâmico e não dispõe de uma implementação de uma <code>class</code> (a palavra-chave <code>class</code> foi introduzida no ES2015, mas é syntax sugar, o JavaScript permanece baseado em <code>prototype</code>).</p>
-
-<p>Quando se trata de herança, o JavaScript tem somente um construtor: objetos. Cada objeto tem um link interno para um outro objeto chamado <code>prototype</code>. Esse objeto <code>prototype</code> também tem um atributo <code>prototype</code>, e assim por diante até o que o valor <code>null</code> seja encontrado como sendo o seu <code>prototype</code>. <code>null</code> que, por definição, não tem <code>prototype</code>, e age como um link final nesta <strong>cadeia de protótipos</strong> (prototype chain).</p>
-
-<p><span id="result_box" lang="pt">Isto<span class="hps"> muitas vezes é</span> <span class="hps">considerado como</span> <span class="hps">um dos</span> <span class="hps">pontos fracos</span> <span class="hps">do JavaScript</span><span>, mas o modelo de</span> <span class="hps">herança prototipal</span> <span class="hps">é de fato</span> <span class="hps">mais potente</span> <span class="hps">do que o modelo</span> <span class="hps">clássico.</span> <span class="hps">É</span><span>,</span> <span class="hps">por exemplo</span><span>,</span> <span class="hps">relativamente</span> <span class="hps">trivial</span> <span class="hps">construir</span> <span class="hps">um</span> "<span class="hps">modelo</span> <span class="hps">clássico" (como na implementaçao de <code>class</code></span>)<span>,</span> <span class="hps">enquanto</span> <span class="hps">o contrário</span> <span class="hps">é</span> <span class="hps">uma</span> <span class="hps">tarefa</span> <span class="hps">muito mais</span> <span class="hps">difícil</span><span>.</span></span></p>
-
-<p><sup>1 </sup><em>N. da T: Como em uma implementação de fila em C, por exemplo.</em></p>
-
-<h2 id="Herança_com_o_encadeamento_de_protótipos">Herança com o encadeamento de protótipos</h2>
-
-<h3 id="Propriedades_de_heranças">Propriedades de heranças</h3>
-
-<p><span id="result_box" lang="pt"><span class="hps">Objetos em JavaScript</span> <span class="hps">são</span> <span class="hps">"sacos"</span> <span class="hps">dinâmicos de</span> <span class="atn hps">propriedades (</span><span>a que se refere</span> <span class="hps">as próprias propriedades</span><span>)</span> <span class="hps">e cada um tem</span> <span class="hps">um link para um</span> <span class="hps">objeto </span><span><code>prototype</code>.</span> <span class="hps">Eis o que acontece</span> <span class="hps">quando se tenta</span> <span class="hps">acessar uma propriedade</span><span>:</span></span></p>
-
-<pre><code>// </code>Vamos criar um objeto o da função f com suas próprias propriedades a e b:<code>
-let f = function () {
-   this.a = 1;
-   this.b = 2;
-}
-let o = new f(); // {a: 1, b: 2}
-
-// </code>adicionar propriedades no protótipo da função f<code>
-f.prototype.b = 3;
-f.prototype.c = 4;</code>
-
-// não defina o protótipo f.prototype = {b: 3, c: 4}; isso vai quebrar a cadeia de protótipos
-// o. [[Prototype]] possui propriedades bec.
-// o. [[Prototype]]. [[Prototype]] é Object.prototype.
-// Finalmente, o. [[Prototype]]. [[Prototype]]. [[Prototype]] é nulo.
-// Este é o fim da cadeia de protótipos, como nulo,
-// por definição, não possui [[Prototype]].
-// Assim, a cadeia completa de protótipos se parece com:
-// {a: 1, b: 2} ---&gt; {b: 3, c: 4} ---&gt; Object.prototype ---&gt; null dfdf
-
-<code>console.log(o.a); // 1
-// Existe uma propriedade 'a' no objeto o? Sim, e seu valor é 1.
-
-console.log(o.b); // 2
-// Existe uma propriedade própria 'b' em o? Sim, e seu valor é 2.
-// O protótipo também tem uma propriedade 'b', mas não é visitado.
-// Isso é chamado de sombreamento de propriedade(Property Shadowing)
-
-console.log(o.c); // 4
-// Existe uma propriedade própria 'c' em o? Não, verifique seu protótipo.
-// Existe uma propriedade 'c' própria em o. [[Prototype]]? Sim, seu valor é 4.
-
-console.log(o.d); // undefined
-// Existe uma propriedade 'd' própria em o? Não, verifique seu prototype.
-// Existe uma propriedade 'd' em o. [[Prototype]]? Não, verifique seu prototype.
-// o. [[Prototype]]. [[Prototype]] é Object.prototype e não há propriedade 'd' por padrão, verifique seu prototype.
-// o. [[Prototype]]. [[Prototype]]. [[Prototype]] é nulo, pare de pesquisar,
-// nenhuma propriedade encontrada, retorne indefinido.</code>
-</pre>
-
-<p><a href="https://repl.it/@khaled_hossain_code/prototype" style="background-color: rgb(255, 255, 255); font-family: Arial, x-locale-body, sans-serif; font-size: 1rem; letter-spacing: -0.00278rem;">Code Link</a></p>
-
-<p><span id="result_box" lang="pt"><span class="hps">Atribuir uma propriedade</span> <span class="hps">a um objeto</span> <span class="hps">cria uma</span> <span class="hps">propriedade nele.</span> <span class="hps">A única</span> <span class="hps">exceção às regras</span> <span class="hps">de obtenção e definição</span> <span class="hps">de comportamento</span> <span class="hps">é quando há</span> <span class="hps">uma propriedade herdada</span> <span class="hps">com </span></span>um <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Defining_getters_and_setters" title="Defining Getters and Setters">getter or a setter</a>.</p>
-
-<h3 id="Herença_de_métodos">Herença de "métodos"</h3>
-
-<p>JavaScript não tem "métodos" como os que conhecemos em linguagens baseadas em classes. Em JavaScript, qualquer função pode ser adicionada em um objeto em forma de propriedade. Uma herança de funções age como a herança de quaisquers outras propriedades que não sejam funções, e podemos inclusive realizar sobre-escrita de função(<em>method overriding</em>)!</p>
-
-<p>Quando uma herança de função é executada, o valor de <a href="/en/JavaScript/Reference/Operators/this" title="this"><code>this</code></a> aponta para o objeto que herdou as propriedades, não para o objeto prototype onde as propriedades foram escritas originalmente.</p>
-
-<pre class="brush: js">var o = {
-  a: 2,
-  m: function(b){
-    return this.a + 1;
-  }
-};
-
-console.log(o.m()); // 3
-// <span class="short_text" id="result_box" lang="pt"><span class="hps">Ao chamar</span> <span class="atn hps">'</span><span>o.m</span><span>'</span> <span class="hps">neste caso,</span> <span class="hps">"this" </span><span class="hps">refere-se a</span> <span class="hps">'o'</span></span>
-
-var p = Object.create(o);
-// 'p' é um objeto que foi herdado de 'o'
-
-p.a = 12; // cria uma propriedade 'a' no objeto 'p'
-console.log(p.m()); // 13
-// Ao chamar 'p.m', 'this' refere-se a 'p'
-// <span id="result_box" lang="pt"><span class="hps">Então,</span> <span class="atn hps">quando '</span><span>p'</span> <span class="hps">herda</span> <span class="hps">a função de</span> <span class="hps">'m'</span> <span class="hps">de</span> <span class="hps">'o'</span><span>,</span> <span class="atn hps">'</span><span>this.a</span><span>'</span> representa <span class="atn hps">'p</span><span>.a</span><span>'</span> que é <span class="hps">a</span> <span class="hps">própria propriedade</span> <span class="hps">'a'</span> <span class="hps">de</span> <span class="hps">'p'</span></span>
-
-</pre>
-
-<h2 id="Maneiras_de_criar_objetos_e_resultados_dos_protótipos_encadeados">Maneiras de criar objetos e resultados dos protótipos encadeados</h2>
-
-<h3 id="Objetos_criados_com_sintaxe_de_construtores">Objetos criados com sintaxe de construtores</h3>
-
-<pre class="brush: js">var o = {a: 1};
-
-// <span id="result_box" lang="pt"><span class="hps">O recém-criado</span> <span class="hps">objecto 'o'</span> <span class="hps">tem</span> <span class="hps">Object.prototype</span> <span class="hps">como o seu</span> <span class="atn hps">[[</span><span>Prototype</span><span>]]</span></span>
-// <span id="result_box" lang="pt"><span class="hps">'o'</span> <span class="hps">não tem</span> <span class="hps">não tem uma propriedade chamada </span><span class="atn hps">'</span><span>hasOwnProperty</span><span>'</span></span>
-// <span id="result_box" lang="pt"><span class="hps">hasOwnProperty</span> <span class="hps">é uma propriedade</span> <span class="hps">própria</span> <span class="hps">de</span> <span class="hps">Object.prototype</span><span>.</span> <span class="hps">Então</span> <span class="hps">'o'</span> <span class="hps">herda</span> <span class="hps">hasOwnProperty</span> <span class="hps">de</span> <span class="hps">Object.prototype</span></span>
-
-// Object.prototype tem null como seu protótipo.
-// o ---&gt; Object.prototype ---&gt; null
-
-var a = ["yo", "whadup", "?"];
-
-// <span id="result_box" lang="pt"><span class="hps">Arrays</span> <span class="hps">herdam de</span> <span class="hps">Array.prototype</span> <span class="hps">(que tem</span> <span class="hps">métodos como</span> <span class="hps">indexOf</span><span>,</span> <span class="hps">forEach</span><span>, etc.)</span></span>
-// A cadeia de protótipos se parece com isso:
-// a ---&gt; Array.prototype ---&gt; Object.prototype ---&gt; null
-
-function f(){
-  return 2;
-}
-
-// <span id="result_box" lang="pt"><span class="hps">Funções</span> <span class="hps">herdam de</span> <span class="hps">Function.prototype</span> <span class="hps">(que tem</span> <span class="hps">métodos como</span> <span class="hps">call, </span><span class="hps">bind,</span> <span class="hps">etc.)</span></span>
-// f ---&gt; Function.prototype ---&gt; Object.prototype ---&gt; null
-</pre>
-
-<h3 id="Com_um_construtor">Com um construtor</h3>
-
-<p>Um "construtor" em JavaScript é "somente" uma função que passa a ser chamada com o operador <a href="/en/JavaScript/Reference/Operators/new" title="new">new</a>.</p>
-
-<pre class="brush: js">function Graph() {
-  this.vertexes = [];
-  this.edges = [];
-}
-
-Graph.prototype = {
-  addVertex: function(v){
-    this.vertexes.push(v);
-  }
-};
-
-var g = new Graph();
-// 'g' é um objeto com as propriedades 'vertexes' e 'edges'.
-// g.[[Prototype]] é o valor de Graph.prototype quando new Graph() é executada.
-</pre>
-
-<h3 id="Com_Object.create">Com Object.create</h3>
-
-<p>ECMAScript 5 introduziu o novo método: <a href="/en/JavaScript/Reference/Global_Objects/Object/create" title="create">Object.create</a>. Invocando este método podemos criar novos objetos. O prototype destes novos objetos é o primeiro argumento do método:</p>
-
-<pre class="brush: js">var a = {a: 1};
-// a ---&gt; Object.prototype ---&gt; null
-
-var b = Object.create(a);
-// b ---&gt; a ---&gt; Object.prototype ---&gt; null
-console.log(b.a); // 1 (inherited)
-
-var c = Object.create(b);
-// c ---&gt; b ---&gt; a ---&gt; Object.prototype ---&gt; null
-
-var d = Object.create(null);
-// d ---&gt; null
-console.log(d.hasOwnProperty); // undefined, <span class="short_text" id="result_box" lang="pt"><span class="hps">porque</span> <span class="hps">não herda de</span> <span class="hps">Object.prototype</span></span>
-</pre>
-
-<div>
-<h3 id="Performace">Performace</h3>
-
-<p>O tempo de pesquisa para as propriedades que estão no alto da cadeia de protótipos pode ter um impacto negativo no desempenho, e isso pode ser significativo no código em que o desempenho é crítico. Além disso, tentando acessar propriedades inexistentes vai sempre atravessar a cadeia cheia do protótipo (full prototype chain).</p>
-
-<p>Porém, quando estamos interagindo com as propriedades de um objeto, <strong>toda</strong> propriedade que está na cadeia do prototype (prototype chain) vai ser enumerada.</p>
-
-<p>Para verificar se um objeto tem uma propriedade definida em si mesmo e não em algum lugar na sua cadeia de protótipo, é necessário usar o método <a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty" title="/ru/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty"><code>hasOwnProperty</code></a> que todos os objetos herdam do Object.prototype.</p>
-
-<p><a href="/en-US/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty" title="/ru/docs/JavaScript/Reference/Global_Objects/Object/hasOwnProperty"><code>hasOwnProperty</code></a> é a única alternativa em JavaScript que lida com propriedades sem atravessar a cadeia de protótipos.</p>
-
-
-<div class="note">Observação: <strong>Não</strong> é suficiente apenas verificar se o valor da propriedade é <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined" title="/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined">undefined</a></code> para saber se ela existe. A propriedade pode muito bem existir e não ter sido inicializada, sendo assim o seu valor undefined.</div>
-
-<div>
-<h3 id="Má_Pratica_Estender_protótipos_nativos">Má Pratica: Estender protótipos nativos</h3>
-
-<p>Um erro frequentemente cometido por programadores é estender um Object.prototype.</p>
-
-<p>Esta técnica é chamada de "monkey patching" e quebra o encapsulamento. Não existe uma boa razão para desorganizar tipos nativos do JavaScript para adicionar uma nova funcionalidade ao mesmo. </p>
-
-<p>O único bom motivo para estender um protótipo nativo do JavaScript é para dar suporte a novas "features" do JavaScript; por exemplo: Array.forEach, etc.</p>
-</div>
-
-<div>
-<h3 id="Conclusão">Conclusão</h3>
-
-<p>É essencial entender bem  "prototypal inheritance" antes de escrever códigos complexos. Tome cuidado com o tamanho da sua cadeia de protótipos, quebre a cadeia caso necessário para evitar problemas de performace. Nunca estenda protótipos nativos a menos que seja para conseguir compatibilidade com novas "features" do JavaScript.</p>
-
-
-</div>
-</div>
-
-<p>{{ languages( {"zh-cn": "zh-cn/JavaScript/Guide/Inheritance_and_the_prototype_chain" } ) }}</p>
diff --git a/files/pt-br/web/javascript/guide/iteratores_e_geradores/index.html b/files/pt-br/web/javascript/guide/iterators_and_generators/index.html
index 13a9b87f11..13a9b87f11 100644
--- a/files/pt-br/web/javascript/guide/iteratores_e_geradores/index.html
+++ b/files/pt-br/web/javascript/guide/iterators_and_generators/index.html
diff --git a/files/pt-br/web/javascript/guide/lacos_e_iteracoes/index.html b/files/pt-br/web/javascript/guide/loops_and_iteration/index.html
index fcf7437612..fcf7437612 100644
--- a/files/pt-br/web/javascript/guide/lacos_e_iteracoes/index.html
+++ b/files/pt-br/web/javascript/guide/loops_and_iteration/index.html
diff --git a/files/pt-br/web/javascript/guide/módulos/index.html b/files/pt-br/web/javascript/guide/modules/index.html
index 6a2cb73687..6a2cb73687 100644
--- a/files/pt-br/web/javascript/guide/módulos/index.html
+++ b/files/pt-br/web/javascript/guide/modules/index.html
diff --git a/files/pt-br/web/javascript/guide/numeros_e_datas/index.html b/files/pt-br/web/javascript/guide/numbers_and_dates/index.html
index 8f08cb3619..8f08cb3619 100644
--- a/files/pt-br/web/javascript/guide/numeros_e_datas/index.html
+++ b/files/pt-br/web/javascript/guide/numbers_and_dates/index.html
diff --git a/files/pt-br/web/javascript/guide/sintaxe_e_tipos/index.html b/files/pt-br/web/javascript/guide/sintaxe_e_tipos/index.html
deleted file mode 100644
index 953a9543de..0000000000
--- a/files/pt-br/web/javascript/guide/sintaxe_e_tipos/index.html
+++ /dev/null
@@ -1,583 +0,0 @@
----
-title: Sintaxe e tipos
-slug: Web/JavaScript/Guide/Sintaxe_e_tipos
----
-<div>{{jsSidebar("JavaScript Guide")}} {{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}</div>
-
-<p class="summary">Este capítulo trata sobre a sintaxe básica do JavaScript, declarações de variáveis, tipos de dados e literais.</p>
-
-<h2 id="Basics" name="Basics">Sintaxe básica</h2>
-
-<p>JavaScript pega emprestado a maior parte de sua sintaxe do Java, mas também é influenciado por Awk, Perl e Python.</p>
-
-<p>JavaScript é <strong>case-sensitive</strong> e usa o conjunto de caracteres <strong>Unicode.</strong></p>
-
-<p>No JavaScript, instruções são chamadas de {{Glossary("Statement", "declarações")}} e são separadas por um ponto e vírgula (;). Espaços, tabulação e uma nova linha são chamados de espaços em branco. O código fonte dos scripts em JavaScript são lidos da esquerda para a direita e são convertidos em uma sequência de elementos de entrada como simbolos, caracteres de controle, terminadores de linha, comentários ou espaço em branco. ECMAScript também define determinadas palavras-chave e literais, e tem regras para inserção automática de ponto e vírgula (<a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#Automatic_semicolon_insertion">ASI</a>) para terminar as declarações. No entanto, recomenda-se sempre adicionar ponto e vírgula no final de suas declarações; isso evitará alguns imprevistos. Para obter mais informações, consulte a referência detalhada sobre a <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar">gramática léxica</a> do JavaScript.</p>
-
-<h2 id="Comentários">Comentários</h2>
-
-<p>A sintaxe dos comentários em JavaScript é semelhante como em C++ e em muitas outras linguagens:</p>
-
-<pre class="brush: js">// comentário de uma linha
-
-/* isto é um comentário longo
-   de múltiplas linhas.
- */
-
-/* Você não pode, porém, /* aninhar comentários */ SyntaxError */</pre>
-
-<h2 id="Declarations" name="Declarations">Declarações</h2>
-
-<p>Existem três tipos de declarações em JavaScript.</p>
-
-<dl>
- <dt>{{jsxref("Statements/var", "var")}}</dt>
- <dd>Declara uma variável, opcionalmente, inicializando-a com um valor.</dd>
- <dt>{{experimental_inline}} {{jsxref("Statements/let", "let")}}</dt>
- <dd>Declara uma variável local de escopo do bloco, opcionalmente, inicializando-a com um valor.</dd>
- <dt>{{experimental_inline}} {{jsxref("Statements/const", "const")}}</dt>
- <dd>Declara uma constante apenas de leitura.</dd>
-</dl>
-
-<h3 id="Variáveis">Variáveis</h3>
-
-<p>Você usa variáveis como nomes simbólicos para os valores em sua aplicação. O nome das variáveis, chamados de {{Glossary("Identifier", "identificadores")}}, obedecem determinadas regras.</p>
-
-<p>Um identificador JavaScript deve começar com uma letra, underline (<code>_</code>), ou cifrão (<code>$</code>); os caracteres subsequentes podem também ser números (0-9). Devido JavaScript ser case-sensitive, letras incluem caracteres de "A" a "Z" (maiúsculos) e caracteres de "a" a "z" (minúsculos).</p>
-
-<p>Você pode usar a ISO 8859-1 ou caracteres Unicode tal como os identificadores å e ü. Você pode também usar as <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals">sequências de escape Unicode</a> como caracteres e identificadores.</p>
-
-<p>Alguns exemplos de nomes legais são <code>Numeros_visitas</code>, <code>temp99</code>, e<code> _nome</code>.</p>
-
-<h3 id="Declarando_variáveis">Declarando variáveis</h3>
-
-<p>Você pode declarar uma variável de três formas:</p>
-
-<ul>
- <li>Com a palavra chave {{jsxref("Statements/var", "var")}}. Por exemplo, var <code>x = 42</code>. Esta sintaxe pode ser usada para declarar tanto variáveis locais como variáveis global.</li>
- <li>Por simples adição de valor. Por exemplo, <code>x = 42</code>. Isso declara uma variável global. Essa declaração gera um aviso de advertência no JavaScript. Você não deve usar essa variante.</li>
- <li>Com a palavra chave {{jsxref("Statements/let", "let")}}. Por exemplo, <code>let y = 13</code>. Essa sintaxe pode ser usada para declarar uma variável local de escopo de bloco. Veja <a href="/pt-BR/docs/Web/JavaScript/Guide/Grammar_and_Types#Variable_scope">escopo de variável</a> abaixo.</li>
-</ul>
-
-<h3 id="Classificando_variáveis">Classificando variáveis</h3>
-
-<p>Uma variável declarada usando a declaração <code>var</code> ou <code>let</code> sem especificar o valor inicial tem o valor  {{jsxref("undefined")}}.</p>
-
-<p>Uma tentativa de acessar uma variável não declarada resultará no lançamento de uma exceção {{jsxref("ReferenceError")}}:</p>
-
-<pre class="brush: js">var a;
-console.log("O valor de a é " + a); // saída "O valor de a é undefined"
-console.log("O valor de b é " + b); // throws ReferenceError exception
-</pre>
-
-<p>Você pode usar <code>undefined</code> para determinar se uma variável tem um valor. No código a seguir, não é atribuído um valor de entrada na variável e a declaração <code><a href="/pt-BR/docs/Web/JavaScript/Reference/Statements/if...else">if</a></code> será avaliada como verdadeira (<code>true</code>).</p>
-
-<pre class="brush: js">var input;
-if(input === undefined){
-  facaIsto();
-} else {
-  facaAquilo();
-}
-</pre>
-
-<p>O valor <code>undefined</code> se comporta como falso (<code>false</code>), quando usado em um contexto booleano. Por exemplo, o código a seguir executa a função <code>myFunction</code> devido o elemento <code>myArray</code> ser undefined:</p>
-
-<pre class="brush: js">var myArray = [];
-if (!myArray[0]) myFunction();
-</pre>
-
-<p>O valor <code>undefined</code> converte-se para <code>NaN</code> quando usado no contexto numérico.</p>
-
-<pre class="brush: js">var a;
-a + 2;  // Avaliado como NaN
-</pre>
-
-<p>Quando você avalia uma variável nula, o valor nulo se comporta como 0 em contextos numéricos e como falso em contextos booleanos. Por exemplo:</p>
-
-<pre class="brush: js">var n = null;
-console.log(n * 32); // a saída para o console será 0.
-</pre>
-
-<h3 id="Variable_scope" name="Variable_scope">Escopo de variável</h3>
-
-<p>Quando você declara uma váriavel fora de qualquer função, ela é chamada de variável <em>global</em>, porque está disponível para qualquer outro código no documento atual. Quando você declara uma variável dentro de uma função, é chamada de variável <em>local</em>,  pois ela está disponível somente dentro dessa função.</p>
-
-<p>JavaScript antes do ECMAScript 6 não possuía escopo de <a href="/pt-BR/docs/Web/JavaScript/Guide/Control_flow_and_error_handling#Block_statement">declaração de bloco</a>; pelo contrário, uma variável declarada dentro de um bloco de uma <em>função </em>é uma variável local (ou contexto <em>global</em>) do bloco que está inserido a função. Por exemplo o código a seguir exibirá 5, porque o escopo de <code>x</code> está na função (ou contexto global) no qual <code>x</code> é declarado, não o bloco, que neste caso é a declaração <code>if</code>. </p>
-
-<pre class="brush: js">if (true) {
-  var x = 5;
-}
-console.log(x);  // 5
-</pre>
-
-<p>Esse comportamento é alterado, quando usado a declaração <code>let</code> introduzida pelo ECMAScript 6.</p>
-
-<pre class="brush: js">if (true) {
-  let y = 5;
-}
-console.log(y);  // ReferenceError: y não está definido
-</pre>
-
-<h3 id="Variable_hoisting" name="Variable_hoisting">Hoisting</h3>
-
-<p>Outra coisa incomum sobre variáveis em JavaScript é que você pode utilizar a variável e declará-la depois, sem obter uma exceção. Este conceito é conhecido como <strong>hoisting</strong>; variáveis em JavaScript são num sentido "hoisted" ou lançada para o topo da função ou declaração. No entanto, as variáveis que são "hoisted" retornarão um valor <code>undefined</code>. Então, mesmo se você usar ou referir a variável e depois declará-la e inicializá-la, ela ainda retornará undefined.</p>
-
-<pre class="brush: js">/**
- * Exemplo 1
- */
-console.log(x === undefined); // exibe "true"
-var x = 3;
-
-/**
- * Exemplo 2
- */
-// returnará um valor undefined
-var myvar = "my value";
-
-(function() {
-  console.log(myvar); // undefined
-  var myvar = "local value";
-})();
-</pre>
-
-<p>Os exemplos acima serão interpretados como:</p>
-
-<pre class="brush: js">/**
- * Exemplo 1
- */
-var x;
-console.log(x === undefined); // exibe "true"
-x = 3;
-
-/**
- * Exemplo 2
- */
-var myvar = "um valor";
-
-(function() {
-  var myvar;
-  console.log(myvar); // undefined
-  myvar = "valor local";
-})();
-</pre>
-
-<p>Devido o hoisting, todas as declarações <code>var</code> em uma função devem ser colocadas no início da função. Essa recomendação de prática deixa o código mais legível.</p>
-
-<h3 id="Variáveis_Globais">Variáveis Globais</h3>
-
-<p>Variáveis globais são propriedades do <em>objeto global</em>. Em páginas web o objeto global é a {{domxref("window")}}, assim você pode configurar e acessar variáveis globais utilizando a sintaxe <code>window.variavel.</code> </p>
-
-<p>Consequentemente, você pode acessar variáveis globais declaradas em uma janela ou frame ou frame de outra janela. Por exemplo, se uma variável chamada phoneNumber é declarada em um documento, você pode consultar esta variável de um frame como <code>parent.phoneNumber</code>.</p>
-
-<h3 id="Constantes">Constantes</h3>
-
-<p>Você pode criar uma constante apenas de leitura por meio da palavra-chave {{jsxref("Statements/const", "const")}}. A sintaxe de um identificador de uma constante é semelhante ao identificador de uma variável: deve começar com uma letra, underline ou cifrão e pode conter caracteres alfabético, numérico ou underline.</p>
-
-<pre class="brush: js">const prefix = '212';
-</pre>
-
-<p>Uma constante não pode alterar seu valor por meio de uma atribuição ou ao ser declarada novamente enquanto o script é executado. Deve ser inicializada com um valor.</p>
-
-<p>As regras de escopo para as constantes são as mesmas para as váriaveis <code>let</code> de escopo de bloco. Se a palavra-chave <code>const</code> for omitida, o identificado é adotado para representar uma variável.</p>
-
-<p>Você não pode declarar uma constante com o mesmo nome de uma função ou variável que estão no mesmo escopo. Por exemplo: </p>
-
-<pre class="example-bad brush: js">// Isto irá causar um  erro
-function f() {};
-const f = 5;
-
-// Isto também irá causar um erro.
-function f() {
-  const g = 5;
-  var g;
-
-  //declarações
-}
-</pre>
-
-<h2 id="Data_structures_and_types" name="Data_structures_and_types">Estrutura de dados e tipos</h2>
-
-<h3 id="Tipos_de_dados">Tipos de dados</h3>
-
-<p>O mais recente padrão ECMAScript define sete tipos de dados:</p>
-
-<ul>
- <li>Seis tipos de dados são os chamados {{Glossary("Primitive", "primitivos")}}:
-  <ul>
-   <li>{{Glossary("Boolean")}}. <code>true</code> e <code>false</code>.</li>
-   <li>{{Glossary("null")}}. Uma palavra-chave que indica valor nulo. Devido JavaScript ser case-sensitive, <code>null</code> não é o mesmo que <code>Null</code>, <code>NULL</code>, ou ainda outra variação.</li>
-   <li>{{Glossary("undefined")}}. Uma propriedade superior cujo valor é indefinido.</li>
-   <li>{{Glossary("Number")}}. <code>42</code> ou <code>3.14159</code>.</li>
-   <li>{{Glossary("String")}}. "Howdy"</li>
-   <li>{{Glossary("Symbol")}} (novo em ECMAScript 6). Um tipo de dado cuja as instâncias são únicas e imutáveis.</li>
-  </ul>
- </li>
- <li>e {{Glossary("Object")}}</li>
-</ul>
-
-<p>Embora esses tipos de dados sejam uma quantidade relativamente pequena, eles permitem realizar funções úteis em suas aplicações.  <span style="line-height: 1.5;">{{jsxref("Object", "Objetos")}} e {{jsxref("Function", "funçõess")}} são outros elementos fundamentais na linguagem. Você pode pensar em objetos como recipientes para os valores, e funções como métodos que suas aplicações podem executar.</span></p>
-
-<h3 id="Conversão_de_tipos_de_dados">Conversão de tipos de dados</h3>
-
-<p>JavaScript é uma linguagem dinamicamente tipada. Isso significa que você não precisa especificar o tipo de dado de uma variável quando declará-la, e tipos de dados são convertidos automaticamente conforme a necessidade durante a execução do script. Então, por exemplo, você pode definir uma variável da seguinte forma:</p>
-
-<pre class="brush: js">var answer = 42;
-</pre>
-
-<p>E depois, você pode atribuir uma string para a mesma variável, por exemplo:</p>
-
-<pre class="brush: js">answer = "Obrigado pelos peixes...";
-</pre>
-
-<p>Devido JavaScript ser dinamicamente tipado, essa declaração não gera uma mensagem de erro.</p>
-
-<p>Em expressões envolvendo valores numérico e string com o operador +, JavaScript converte valores numérico para strings. Por exemplo, considere a seguinte declaração:</p>
-
-<pre class="brush: js">x = "A resposta é " + 42 // "A resposta é 42"
-y = 42 + " é a resposta" // "42 é a resposta"
-</pre>
-
-<p>Nas declarações envolvendo outros operadores,  JavaScript não converte valores numérico para strings. Por exemplo:</p>
-
-<pre class="brush: js">"37" - 7 // 30
-"37" + 7 // "377"
-</pre>
-
-<h3 id="Convertendo_strings_para_números">Convertendo strings para números</h3>
-
-<p>No caso de um valor que representa um número está armazenado na memória como uma string, existem métodos para a conversão.</p>
-
-<ul>
- <li id="parseInt()_and_parseFloat()">{{jsxref("parseInt", "parseInt()")}}</li>
- <li>{{jsxref("parseFloat", "parseFloat()")}}</li>
-</ul>
-
-<p>parseInt irá retornar apenas números inteiros, então seu uso é restrito para a casa dos decimais. Além disso, é uma boa prática ao usar parseInt incluir o parâmetro da base. O parâmetro da base é usado para especificar qual sistema númerico deve ser usado.</p>
-
-<p><font face="Consolas, Liberation Mono, Courier, monospace">Uma método alternativo de conversão de um número em forma de string é com o operador <code>+</code> (operador soma):</font></p>
-
-<pre class="brush: js">"1.1" + "1.1" = "1.11.1"
-(+"1.1") + (+"1.1") = 2.2
-// Nota: Os parênteses foram usados para deixar mais legível o código, ele não é requirido.</pre>
-
-<h2 id="Literals" name="Literals">Literais</h2>
-
-<p>Você usa literais para representar valores em JavaScript. Estes são valores fixados, não variáveis, que você <code>literalmente</code> insere em seu script. Esta seção descreve os seguintes tipos literais:</p>
-
-<ul>
- <li>{{anch("Array literal")}}</li>
- <li>{{anch("Literais boolean")}}</li>
- <li>{{anch("Literais de ponto flutuante")}}</li>
- <li>{{anch("Inteiros")}}</li>
- <li>{{anch("Objeto literal")}}</li>
- <li>{{anch("String literal")}}</li>
-</ul>
-
-<h3 id="Array_literal">Array literal</h3>
-
-<p>Um literal de array é uma lista de zero ou mais expressões, onde cada uma delas representam um elemento do array, inseridas entre colchetes (<code>[]</code>). Quando você cria um array usando um array literal, ele é inicializado  com os valores especificados como seus elementos, e seu comprimento é definido com o  número de elementos especificados.</p>
-
-<p>O exemplo a seguir cria um array <code>coffees</code> com três elementos e um comprimento de três:</p>
-
-<pre class="brush: js">var coffees = ["French Roast", "Colombian", "Kona"];
-</pre>
-
-<div class="note">
-<p><strong>Nota :</strong> Um array literal é um tipo de inicializador de objetos. Veja <a href="/pt-BR/docs/Web/JavaScript/Guide/Working_with_Objects#Using_object_initializers" title="en-US/docs/JavaScript/Guide/Working with Objects#Using Object Initializers">Usando inicializadores de Objetos</a>.</p>
-</div>
-
-<p>Se um array é criado usando um literal no topo do script, JavaScript interpreta o array cada vez que avalia a expressão que contêm o array literal. Além disso, um literal usado em uma função é criado cada vez que a função é chamada.</p>
-
-<p>Array literal são também um array de objetos. Veja  {{jsxref("Array")}} e <a href="/pt-BR/docs/Web/JavaScript/Guide/Indexed_collections">Coleções indexadas</a> para detalhes sobre array de objetos.</p>
-
-<h4 id="Vírgulas_extras_em_array_literal">Vírgulas extras em array literal</h4>
-
-<p>Você não precisa especificar todos os elementos em um array literal. Se você colocar duas vírgulas em uma linha, o array é criado com <code>undefined</code> para os elementos não especificados. O exemplo a seguir cria um array chamado <code>fish</code>:</p>
-
-<pre class="brush: js">var fish = ["Lion", , "Angel"];
-</pre>
-
-<p>Esse array tem dois elementos com valores e um elemento vazio (<code>fish[0]</code> é "Lion", <code>fish[1]</code> é <code>undefined</code>, e <code>fish[2]</code> é "Angel" ).</p>
-
-<p>Se você incluir uma vírgula à direita no final da lista dos elementos, a vírgula é ignorada. No exemplo a seguir, o comprimento do array é três. Não há nenhum <code>myList[3]</code>. Todas as outras vírgulas na lista indicam um novo elemento.</p>
-
-<div class="note">
-<p><strong>Nota :</strong> Vírgulas à direita podem criar erros em algumas versões de navegadores web antigos, é recomendável removê-las.</p>
-</div>
-
-<pre class="brush: js">var myList = ['home', , 'school', ];
-</pre>
-
-<p>No exemplo a seguir, o comprimento do array é quatro, e <code>myList[0]</code> e <code>myList[2]</code> são <code>undefined</code>.</p>
-
-<pre class="brush: js">var myList = [ , 'home', , 'school'];
-</pre>
-
-<p>No exemplo a seguir, o comprimento do array é quatro, e <code>myList[1]</code> e <code>myList[3]</code> são <code>undefined</code>. Apenas a última vírgula é ignorada.</p>
-
-<pre class="brush: js">var myList = ['home', , 'school', , ];
-</pre>
-
-<p>Entender o comportamento de vírgulas extras é importante para a compreensão da linguagem JavaScript, no entanto, quando você escrever seu próprio código: declarar explicitamente os elementos em falta como <code>undefined</code> vai aumentar a clareza do código, e consequentemente na sua manutenção.</p>
-
-<h3 id="Literais_Boolean">Literais Boolean</h3>
-
-<p>O tipo Boolean tem dois valores literal: <code>true</code> e <code>false</code>.</p>
-
-<p>Não confunda os valores primitivos Boolean <code>true</code> e <code>false</code> com os valores <code>true</code> e <code>false</code> do objeto Boolean. O objeto Boolean é um invólucro em torno do tipo de dado primitivo. Veja {{jsxref("Boolean")}} para mais informação.</p>
-
-<h3 id="Inteiros">Inteiros</h3>
-
-<p>Inteiros podem sem expressos em decimal (base 10), hexadecimal (base 16), octal (base 8) e binário (base 2).</p>
-
-<ul>
- <li>Decimal inteiro literal consiste em uma sequência de dígitos sem um 0 (zero).</li>
- <li>0 (zero) em um inteiro literal indica que ele está em octal. Octal pode incluir somente os dígitos 0-7.</li>
- <li>0x (ou 0X) indica um hexadecimal. Inteiros hexadecimais podem incluir dígitos (0-9) e as letras a-f e A-F.</li>
- <li>0b (ou 0B) indica um binário. Inteiros binário podem incluir apenas os dígitos 0 e 1.</li>
-</ul>
-
-<p>Alguns exemplos de inteiros literal são:</p>
-
-<pre class="eval">0, 117 and -345 (decimal, base 10)
-015, 0001 and -077 (octal, base 8)
-0x1123, 0x00111 and -0xF1A7 (hexadecimal, "hex" or base 16)
-0b11, 0b0011 and -0b11 (binário, base 2)
-</pre>
-
-<p>Para maiores informações, veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#Numeric_literals">Literais numérico na referência Léxica</a>.</p>
-
-<h3 id="Literais_de_ponto_flutuante">Literais de ponto flutuante</h3>
-
-<p>Um literal de ponto flutuante pode ter as seguintes partes:</p>
-
-<ul>
- <li>Um inteiro decimal que pode ter sinal (precedido por "<code>+</code>" ou "<code>-</code>"),</li>
- <li>Um ponto decimal ("<code>.</code>"),</li>
- <li>Uma fração (outro número decimal),</li>
- <li>Um expoente.</li>
-</ul>
-
-<p>O expoente é um "e" ou "E" seguido por um inteiro, que pode ter sinal (precedido por "+" ou "-"). Um literal de ponto flutuante  deve ter no mínimo um dígito e um ponto decimal ou "e" (ou "E").</p>
-
-<p>Mais sucintamente, a sintaxe é:</p>
-
-<pre class="eval">[(+|-)][digitos][.digitos][(E|e)[(+|-)]digitos]
-</pre>
-
-<p>Por exemplo:</p>
-
-<pre class="eval">3.1415926
--.123456789
--3.1E+12
-.1e-23
-</pre>
-
-<h3 id="Objeto_literal">Objeto literal</h3>
-
-<p>Um objeto literal é uma lista de zero ou mais pares de nomes de propriedades e valores associados de de um objeto, colocado entre chaves (<code>{}</code>). Você não deve usar um objeto literal no início de uma declaração. Isso levará a um erro ou não se comportará conforme o esperado, porque o <code>{</code> será interpretado como início de um bloco.</p>
-
-<p>Segue um exemplo de um objeto literal. O primeiro elemento do objeto <code>car </code>define uma propriedade, <code>myCar</code>, e atribui para ele uma nova string, "Saturn"; o segundo elemento, a propriedade <code>getCar</code>, é imediatamente atribuído o resultado de chamar uma função (<code>carTypes("Honda")</code>); o terceiro elemento, a propriedade especial, usa uma variável existente (<code>sales)</code>.</p>
-
-<pre class="brush: js">var sales = "Toyota";
-
-function carTypes(name) {
-  if (name == "Honda") {
-    return name;
-  } else {
-    return "Sorry, we don't sell " + name + ".";
-  }
-}
-
-var car = { myCar: "Saturn", getCar: carTypes("Honda"), special: sales };
-
-console.log(car.myCar);   // Saturn
-console.log(car.getCar);  // Honda
-console.log(car.special); // Toyota
-</pre>
-
-<p>Além disso, você pode usar um literal numérico ou string para o nome de uma propriedade ou aninhar um objeto dentro do outro. O exemplo a seguir usar essas opções.</p>
-
-<pre class="brush: js">var car = { manyCars: {a: "Saab", "b": "Jeep"}, 7: "Mazda" };
-
-console.log(car.manyCars.b); // Jeep
-console.log(car[7]); // Mazda
-</pre>
-
-<p>Nomes de propriedades de objeto podem ser qualquer string, incluindo uma string vazia. Caso o nome da propriedade não seja um {{Glossary("Identifier","identificador")}} JavaScript ou número, ele deve ser colocado entre aspas. Nomes de propriedades que não possuem identificadores válido, também não podem ser acessadas pela propriedade de ponto (<code>.</code>), mas podem ser acessadas e definidas com a notação do tipo array ("<code>[]</code>").</p>
-
-<pre class="brush: js">var unusualPropertyNames = {
-  "": "Uma string vazia",
-  "!": "Bang!"
-}
-console.log(unusualPropertyNames."");   // SyntaxError: string inesperada
-console.log(unusualPropertyNames[""]);  // Um string vazia
-console.log(unusualPropertyNames.!);    // SyntaxError: símbolo ! inesperado
-console.log(unusualPropertyNames["!"]); // Bang!</pre>
-
-<p>Observe:</p>
-
-<pre class="brush: js">var foo = {a: "alpha", 2: "two"};
-console.log(foo.a);    // alpha
-console.log(foo[2]);   // two
-//console.log(foo.2);  // Error: missing ) after argument list
-//console.log(foo[a]); // Error: a não está definido
-console.log(foo["a"]); // alpha
-console.log(foo["2"]); // two
-</pre>
-
-<h3 id="String_Literal">String Literal</h3>
-
-<p>Uma string literal são zero ou mais caracteres dispostos em aspas duplas (<code>"</code>) ou aspas simples (<code>'</code>). Uma sequência de caracteres deve ser delimitada por aspas do mesmo tipo; ou seja,  as duas aspas simples ou ambas aspas duplas. A seguir um exemplo de strings literais.</p>
-
-<pre class="eval">"foo"
-'bar'
-"1234"
-"um linha \n outra linha"
-"John's cat"
-</pre>
-
-<p>Você pode chamar qualquer um dos métodos do objeto string em uma string literal - JavaScript automaticamente converte a string literal para um objeto string temporário, chama o método, em seguida, descarta o objeto string temporário. Você também pode usar a propriedade <code>String.length</code> com uma string literal:</p>
-
-<pre class="brush: js">console.log("John's cat".length)
-// Irá exibir a quantidade de caracteres na string incluindo o espaço em branco.
-// Nesse caso, 10 caracteres.
-</pre>
-
-<p>Você deve usar string literal, a não ser que você precise usar um objeto string. Veja {{jsxref("String")}} para detalhes sobre objetos de strings.</p>
-
-<h4 id="Uso_de_caracteres_especiais_em_string">Uso de caracteres especiais em string</h4>
-
-<p>Além dos caracteres comuns, você também pode incluir caracteres especiais em strings, como mostrado no exemplo a seguir.</p>
-
-<pre class="brush: js">"uma linha \n outra linha"
-</pre>
-
-<p>A tabela a seguir lista os caracteres especiais que podem ser usados em strings no JavaScript.</p>
-
-<table class="standard-table">
- <caption>Tabela: Caracteres especiais no JavaScript</caption>
- <thead>
-  <tr>
-   <th scope="col">Caracter</th>
-   <th scope="col">Descrição</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>\0</code></td>
-   <td>Byte nulo</td>
-  </tr>
-  <tr>
-   <td><code>\b</code></td>
-   <td>Backspace</td>
-  </tr>
-  <tr>
-   <td><code>\f</code></td>
-   <td>Alimentador de formulário</td>
-  </tr>
-  <tr>
-   <td><code>\n</code></td>
-   <td>Nova linha</td>
-  </tr>
-  <tr>
-   <td><code>\r</code></td>
-   <td>Retorno do carro</td>
-  </tr>
-  <tr>
-   <td><code>\t</code></td>
-   <td>Tabulação</td>
-  </tr>
-  <tr>
-   <td><code>\v</code></td>
-   <td>Tabulação vertical</td>
-  </tr>
-  <tr>
-   <td><code>\'</code></td>
-   <td>Apóstrofo ou aspas simples</td>
-  </tr>
-  <tr>
-   <td><code>\"</code></td>
-   <td>Aspas dupla</td>
-  </tr>
-  <tr>
-   <td><code>\\</code></td>
-   <td>Caractere de barra invertida</td>
-  </tr>
-  <tr>
-   <td><code>\<em>XXX</em></code></td>
-   <td>
-    <p>Caractere com a codificação Latin-1 especificada por três dígitos octal <em>XXX </em>entre 0 e 377. Por exemplo, \251 é sequência octal para o símbolo de direitos autorais.</p>
-   </td>
-  </tr>
-  <tr>
-  </tr>
-  <tr>
-   <td><code>\x<em>XX</em></code></td>
-   <td>
-    <p>Caractere com a codificação Latin-1 especificada por dois dígitos hexadecimal <em>XX</em> entre 00 e FF. Por exemplo, \xA9 é a sequência hexadecimal para o símbolo de direitos autorais.</p>
-   </td>
-  </tr>
-  <tr>
-  </tr>
-  <tr>
-   <td><code>\u<em>XXXX</em></code></td>
-   <td>
-    <p>Caractere Unicode especificado por quatro dígitos hexadecimal <em>XXXX</em>. Por exemplo, \u00A9 é a sequência Unicode para o símbolo de direitos autorais. Veja <a href="/pt-BR/docs/Web/JavaScript/Reference/Lexical_grammar#String_literals">sequências de escape Unicode</a>.</p>
-   </td>
-  </tr>
- </tbody>
-</table>
-
-<h4 id="Caracteres_de_escape">Caracteres de escape</h4>
-
-<p>Para caracteres não listados na tabela, se precedidos de barra invertida ela é ignorada, seu uso está absoleto e deve ser ignorado.</p>
-
-<p>Você pode inserir uma aspa dentro de uma string precendendo-a com uma barra invertida. Isso  é conhecido como <em>escaping</em> das aspas. Por exemplo:</p>
-
-<pre class="brush: js">var quote = "Ele lê \"The Cremation of Sam McGee\" de R.W. Service.";
-console.log(quote);
-</pre>
-
-<p>O resultado disso seria:</p>
-
-<pre class="eval">Ele lê "The Cremation of Sam McGee" de R.W. Service.
-</pre>
-
-<p>Para incluir uma barra invertida dentro de uma string, você deve escapar o caractere de barra invertida. Por exemplo, para atribuir o caminho do arquivo <code>c:\temp </code>para uma string, utilize o seguinte:</p>
-
-<pre class="brush: js">var home = "c:\\temp";
-</pre>
-
-<p>Você também pode escapar quebras de linhas, precedendo-as com barra invertida. A barra invertida e a quebra de linha são ambas removidas da string.</p>
-
-<pre class="brush: js">var str = "esta string \
-está quebrada \
-em várias\
-linhas."
-console.log(str);   // esta string está quebrada em várias linhas.
-</pre>
-
-<p>Embora JavaScript não tenha sintaxe "heredoc", você pode adicionar uma quebra de linha e um escape de quebra de linha no final de cada linha:</p>
-
-<pre class="brush: js">var poem =
-"Rosas são vermelhas,\n\
-Violetas são azul.\n\
-Eu sou esquizofrênico,\n\
-e é isso que sou."
-</pre>
-
-<h2 id="Mais_informação">Mais informação</h2>
-
-<p>Este capítulo focou na sintaxe básica das declarações e tipos. Para saber mais sobre a linguagem JavaScript, veja também os seguintes capítulos deste guia:</p>
-
-<ul>
- <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Control_flow_and_error_handling">Controle de fluxo e manipulação de erro</a></li>
- <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Loops_and_iteration">Laços e iteração</a></li>
- <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Functions">Funções</a></li>
- <li><a href="/pt-BR/docs/Web/JavaScript/Guide/Expressions_and_Operators">Expressões e operadores</a></li>
-</ul>
-
-<p>No próximo capítulo, veremos a construção de controle de fluxos e manipulação de erro.</p>
-
-<p>{{PreviousNext("Web/JavaScript/Guide/Introduction", "Web/JavaScript/Guide/Control_flow_and_error_handling")}}</p>
diff --git a/files/pt-br/web/javascript/guide/formatando_texto/index.html b/files/pt-br/web/javascript/guide/text_formatting/index.html
index 1b4bb50772..1b4bb50772 100644
--- a/files/pt-br/web/javascript/guide/formatando_texto/index.html
+++ b/files/pt-br/web/javascript/guide/text_formatting/index.html
diff --git a/files/pt-br/web/javascript/guide/usando_promises/index.html b/files/pt-br/web/javascript/guide/using_promises/index.html
index a0dd09c8c2..a0dd09c8c2 100644
--- a/files/pt-br/web/javascript/guide/usando_promises/index.html
+++ b/files/pt-br/web/javascript/guide/using_promises/index.html
diff --git a/files/pt-br/web/javascript/guide/trabalhando_com_objetos/index.html b/files/pt-br/web/javascript/guide/working_with_objects/index.html
index 1dccaeef2e..1dccaeef2e 100644
--- a/files/pt-br/web/javascript/guide/trabalhando_com_objetos/index.html
+++ b/files/pt-br/web/javascript/guide/working_with_objects/index.html