remove retired locales (#699)

author: Ryan Johnson <rjohnson@mozilla.com> 2021-04-29 16:16:42 -0700
committer: GitHub <noreply@github.com> 2021-04-29 16:16:42 -0700
commit: 95aca4b4d8fa62815d4bd412fff1a364f842814a (patch)
tree: 5e57661720fe9058d5c7db637e764800b50f9060 /files/pt-pt/web/javascript/reference/global_objects
parent: ee3b1c87e3c8e72ca130943eed260ad642246581 (diff)
download: translated-content-95aca4b4d8fa62815d4bd412fff1a364f842814a.tar.gz
translated-content-95aca4b4d8fa62815d4bd412fff1a364f842814a.tar.bz2
translated-content-95aca4b4d8fa62815d4bd412fff1a364f842814a.zip
38 files changed, 0 insertions, 6813 deletions
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/concat/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/concat/index.html
deleted file mode 100644
index 237818a04c..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/concat/index.html
+++ /dev/null
@@ -1,205 +0,0 @@
----
-title: Array.prototype.concat()
-slug: Web/JavaScript/Reference/Global_Objects/Array/concat
-tags:
-  - JavaScript
-  - Prototipo
-  - Referencia
-  - Vector
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/concat
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>concat()</strong></code> é usado para concatenar dois ou mais vectores. Este método não altera os vectores existentes, devolvendo ao invés um novo vector.</p>
-
-<pre class="brush: js">var vec1 = ['a', 'b', 'c'];
-var vec2 = ['d', 'e', 'f'];
-
-var vec3 = vec1.concat(vec2);
-
-// vec3 é um novo vector [ "a", "b", "c", "d", "e", "f" ]</pre>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox">var <var>novo_vector</var> = <var>velho_vector</var>.concat(<var>valor1</var>[, <var>valor2</var>[, ...[, <var>valorN</var>]]])</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>valor<em>N</em></code></dt>
- <dd>Vectores e/ou valores a concatenar num novo vector. Veja a descrição detalhada abaixo.</dd>
-</dl>
-
-<h3 id="Valor_devolvido">Valor devolvido</h3>
-
-<p>Uma nova instância de {{jsxref("Array")}}.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O método <code>concat</code> cria um novo vector constituído pelos elementos no vector em que foi chamado, seguidos por ordem por, cada argumento, os elementos desse argumento (se o argumento é um vector), ou o argumento em si (se o argumento não é um vector). Não entra recursivamente em vectores inclusos.</p>
-
-<p>O método <code>concat</code> não altera <code>this</code> ou qualquer dos vectores fornecidos como argumentos, devolve sim uma cópia superficial (shallow copy) que contém cópias dos mesmos elementos combinados dos vectores originais. Os elementos dos vectores originais são copiados para o novo vector da seguinte forma:</p>
-
-<ul>
- <li>Object references (and not the actual object): <code>concat</code> copies object references into the new array. Both the original and new array refer to the same object. That is, if a referenced object is modified, the changes are visible to both the new and original arrays. This includes elements of array arguments that are also arrays.</li>
- <li>Strings, numbers and booleans (not {{jsxref("Global_Objects/String", "String")}}, {{jsxref("Global_Objects/Number", "Number")}}, and {{jsxref("Global_Objects/Boolean", "Boolean")}} objects): <code>concat</code> copies the values of strings and numbers into the new array.</li>
-</ul>
-
-<div class="note">
-<p><strong>Note:</strong> Concatenating array(s)/value(s) will leave the originals untouched. Furthermore, any operation on the new array(only if the element is not object reference) will have no effect on the original arrays, and vice versa.</p>
-</div>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Concatenar_dois_vectores">Concatenar dois vectores</h3>
-
-<p>O código que se segue concatena dois vectores:</p>
-
-<pre class="brush: js">var alfa = ['a', 'b', 'c'];
-var numerico = [1, 2, 3];
-
-alfa.concat(numerico);
-// resulta em ['a', 'b', 'c', 1, 2, 3]
-</pre>
-
-<h3 id="Concatenar_três_vectores">Concatenar três vectores</h3>
-
-<p>O código que se segue concatena três vectores:</p>
-
-<pre class="brush: js">var num1 = [1, 2, 3],
-    num2 = [4, 5, 6],
-    num3 = [7, 8, 9];
-
-var nums = num1.concat(num2, num3);
-
-console.log(nums);
-// resulta em [1, 2, 3, 4, 5, 6, 7, 8, 9]
-</pre>
-
-<h3 id="Concatenar_valores_para_um_vector">Concatenar valores para um vector</h3>
-
-<p>O código que se segue concatena três valores a um vector:</p>
-
-<pre class="brush: js">var alfa = ['a', 'b', 'c'];
-
-var alfaNumerico = alfa.concat(1, [2, 3]);
-
-console.log(alphaNumeric);
-// resulta em ['a', 'b', 'c', 1, 2, 3]
-</pre>
-
-<h3 id="Concatenar_vectores_inclusos">Concatenar vectores inclusos</h3>
-
-<p>O código que se segue concatena vectores inclusos e demonstra retenção de referências:</p>
-
-<pre class="brush: js">var num1 = [[1]];
-var num2 = [2, [3]];
-
-var nums = num1.concat(num2);
-
-console.log(nums);
-// resulta em [[1], 2, [3]]
-
-// modificar o primeiro elemento de num1
-num1[0].push(4);
-
-console.log(nums);
-// resulta em [[1, 4], 2, [3]]
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Definição inicial. Implementado no JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4.4.4', 'Array.prototype.concat')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.concat', 'Array.prototype.concat')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.concat', 'Array.prototype.concat')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Característica</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Edge</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatChrome("1.0")}}</td>
-   <td>{{CompatGeckoDesktop("1.7")}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatIE("5.5")}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Característica</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("Array.push", "push")}} / {{jsxref("Array.pop", "pop")}} — adicionar/eliminar elementos no fim do vector</li>
- <li>{{jsxref("Array.unshift", "unshift")}} / {{jsxref("Array.shift", "shift")}} — adicionar/eliminar elementos no início do vector</li>
- <li>{{jsxref("Array.splice", "splice")}} — adicionar e/ou eliminar elementos no local especificado do vector</li>
- <li>{{jsxref("String.prototype.concat()")}}</li>
- <li>{{jsxref("Symbol.isConcatSpreadable")}} – control flattening.</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/find/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/find/index.html
deleted file mode 100644
index 3eedeb54a9..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/find/index.html
+++ /dev/null
@@ -1,210 +0,0 @@
----
-title: Array.prototype.find()
-slug: Web/JavaScript/Reference/Global_Objects/Array/find
-tags:
-  - Array
-  - ECMAScript 2015
-  - JavaScript
-  - Method
-  - polyfill
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/find
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>find()</strong></code> retorna o <strong>valor</strong> do primeiro elemento do array que satisfaça a função de teste fornecida. Caso contrário o valor {{jsxref("undefined")}} é retornado.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/array-find.html")}}</div>
-
-
-
-<p>Ver também o método {{jsxref("Array.findIndex", "findIndex()")}} , o qual retorna o <strong>index</strong> de um elemento encontrado num array, em alternativa do seu valor.</p>
-
-<p>É possível obter a posição de um elemento ou verificar a sua existência num array, através da função {{jsxref("Array.prototype.indexOf()")}} ou {{jsxref("Array.prototype.includes()")}}.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><var>arr</var>.find(<var>callback</var>[, <var>thisArg</var>])</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>callback</code></dt>
- <dd>Função a executar em cada elemento do array, utilizando três argumentos:
- <dl>
-  <dt><code>element</code></dt>
-  <dd>O elemento a ser processado no array.</dd>
-  <dt><code>index</code>{{optional_inline}}</dt>
-  <dd>O index do elemento a ser processado no array.</dd>
-  <dt><code>array</code>{{optional_inline}}</dt>
-  <dd>O array no qual o método <code>find</code> foi chamado.</dd>
- </dl>
- </dd>
- <dt><code>thisArg</code> <code>{{Optional_inline}}</code></dt>
- <dd>Objeto para usar como <code>this</code> ao executar a <code>callback</code>.</dd>
-</dl>
-
-<h3 id="Valor_de_retorno">Valor de retorno</h3>
-
-<p>Um valor do array caso um elemento passe no teste; caso contrário, {{jsxref("undefined")}}.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O método<code>find</code> executa a <code>callback</code> uma vez para cada index do array até ser encontrado um no qual a <code>callback</code> retorna o valor true. Caso um elemento seja encontrado, o método <code>find</code> retorna imediatamente o seu valor. Caso contrário, o método <code>find</code> retorna {{jsxref("undefined")}}. A função de <code>callback</code> é invocada para cada index do array do <code>0</code> ao <code>length - 1</code> e é invocada para todos os indexes, não apenas nos que tem valor. Isto pode significar que é menos eficiente para o um array com muitos elementos sem valor (sparse array) do que outros métodos que visitam apenas os elementos com valor.</p>
-
-<p>A função de <code>callback</code> é invocada com 3 parâmetros: o valor do elemento, o index do elemento, e o Array no qual é executado.</p>
-
-<p>Se o parâmetro <code>thisArg</code> for disponibilizado ao método <code>find</code>, este será usado como <code>this</code> para cada invocação da <code>callback</code>. Caso contrário, será usado o valor {{jsxref("undefined")}}.</p>
-
-<p>O método <code>find</code> não altera o array no qual é invocado.</p>
-
-<p>A quantidade de elementos processados pelo método <code>find</code> é definida antes da invocação da <code>callback</code>. Os elementos adicionados ao array após o método <code>find</code> ter iniciado não serão visitados pela <code>callback</code>. Se um elemento existente e não visitado, for alterado pela <code>callback</code>, o seu valor que foi passado para a <code>callback</code> será o valor a ser avaliado pelo método <code>find</code>; Os elementos eliminados após o inicio do método find também serão visitados.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Encontrar_um_objeto_num_array_através_de_uma_das_suas_propriedades">Encontrar um objeto num array através de uma das suas propriedades</h3>
-
-<pre class="brush: js">var inventory = [
-    {name: 'apples', quantity: 2},
-    {name: 'bananas', quantity: 0},
-    {name: 'cherries', quantity: 5}
-];
-
-function isCherries(fruit) {
-    return fruit.name === 'cherries';
-}
-
-console.log(inventory.find(isCherries));
-// { name: 'cherries', quantity: 5 }</pre>
-
-<h3 id="Encontrar_um_número_primo_num_array">Encontrar um número primo num array</h3>
-
-<p>O seguinte exemplo encontra um elemento no array que seja um número primo (caso não exista, retorna {{jsxref("undefined")}} ).</p>
-
-<pre class="brush: js">function isPrime(element, index, array) {
-  var start = 2;
-  while (start &lt;= Math.sqrt(element)) {
-    if (element % start++ &lt; 1) {
-      return false;
-    }
-  }
-  return element &gt; 1;
-}
-
-console.log([4, 6, 8, 12].find(isPrime)); // undefined, not found
-console.log([4, 5, 8, 12].find(isPrime)); // 5
-</pre>
-
-<p>O seguinte exemplo, apresenta como os elementos não existentes e eliminados são visitados e o seu valor passado para a callback será o seu valor quando visitado.</p>
-
-<pre class="brush: js">// Declare array with no element at index 2, 3 and 4
-var a = [0,1,,,,5,6];
-
-// Shows all indexes, not just those that have been assigned values
-a.find(function(value, index) {
-  console.log('Visited index ' + index + ' with value ' + value);
-});
-
-// Shows all indexes, including deleted
-a.find(function(value, index) {
-
-  // Delete element 5 on first iteration
-  if (index == 0) {
-    console.log('Deleting a[5] with value ' + a[5]);
-    delete a[5];
-  }
-  // Element 5 is still visited even though deleted
-  console.log('Visited index ' + index + ' with value ' + value);
-});
-
-</pre>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<p>Este método foi adicionado ao <em>ECMAScript 2015 Language Specification </em>e pode não estar disponível em todas as implementações de JavaScript. É possível desenvolver o polyfill do método find com o seguinte código:</p>
-
-<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.find
-if (!Array.prototype.find) {
-  Object.defineProperty(Array.prototype, 'find', {
-    value: function(predicate) {
-     // 1. Let O be ? ToObject(this value).
-      if (this == null) {
-        throw new TypeError('"this" is null or not defined');
-      }
-
-      var o = Object(this);
-
-      // 2. Let len be ? ToLength(? Get(O, "length")).
-      var len = o.length &gt;&gt;&gt; 0;
-
-      // 3. If IsCallable(predicate) is false, throw a TypeError exception.
-      if (typeof predicate !== 'function') {
-        throw new TypeError('predicate must be a function');
-      }
-
-      // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
-      var thisArg = arguments[1];
-
-      // 5. Let k be 0.
-      var k = 0;
-
-      // 6. Repeat, while k &lt; len
-      while (k &lt; len) {
-        // a. Let Pk be ! ToString(k).
-        // b. Let kValue be ? Get(O, Pk).
-        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
-        // d. If testResult is true, return kValue.
-        var kValue = o[k];
-        if (predicate.call(thisArg, kValue, k, o)) {
-          return kValue;
-        }
-        // e. Increase k by 1.
-        k++;
-      }
-
-      // 7. Return undefined.
-      return undefined;
-    }
-  });
-}
-</pre>
-
-<p>É melhor não utilizar o polyfill <code>Array.prototype</code> para motores JavaScript obsoletos que não suportem métodos <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code>, uma vez que, não é possível torna-los não-enumeráveis.</p>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-array.prototype.find', 'Array.prototype.find')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.find', 'Array.prototype.find')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_Browsers">Compatibilidade de Browsers</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Array.find")}}</p>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.findIndex()")}} – procurar e obter um index</li>
- <li>{{jsxref("Array.prototype.includes()")}} – testar se existe um valor num array</li>
- <li>{{jsxref("Array.prototype.filter()")}} – encontrar todos os elementos</li>
- <li>{{jsxref("Array.prototype.every()")}} – testar se todos os elementos cumprem o requisito</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/foreach/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/foreach/index.html
deleted file mode 100644
index 77e1bcc9d9..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/foreach/index.html
+++ /dev/null
@@ -1,328 +0,0 @@
----
-title: Array.prototype.forEach()
-slug: Web/JavaScript/Reference/Global_Objects/Array/forEach
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/forEach
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>forEach()</strong></code> executa a função que foi fornecida uma vez para cada elemento do vetor (array).</p>
-
-<div>{{EmbedInteractiveExample("pages/js/array-foreach.html")}}</div>
-
-<p class="hidden">A origem deste exemplo interactivo está armazenado num repositório do GitHub. Se queres contribuir para o projecto dos exemplos interactivos, por favor clona <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> e manda-nos um pull request.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><var>vet</var>.forEach(function <var>callback(presenteValor[, indice[, vetor]]) {
-    //o teu iterador
-}</var>[, <var>argThis</var>]);</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>callback</code></dt>
- <dd>Função a executar para cada elemento, levando três argumentos:
- <dl>
-  <dt><code>presenteValor</code></dt>
-  <dd>Valor do presente elemento a ser processado do vetor (array).</dd>
-  <dt><code>indice</code>{{optional_inline}}</dt>
-  <dd>Índice do presente elemento a ser processado do vetor (array).</dd>
-  <dt><code>vet</code>{{optional_inline}}</dt>
-  <dd>O vetor (array) a que o <code>forEach()</code> está a ser aplicado.</dd>
- </dl>
- </dd>
- <dt><code>argThis</code> {{Optional_inline}}</dt>
- <dd>
- <p>Valor a usar como <code><strong>this</strong></code> (ou seja o <code>Object</code> de referência) quando é executado o <code>callback</code>.</p>
- </dd>
-</dl>
-
-<h3 id="Valor_devolvido">Valor devolvido</h3>
-
-<p>{{jsxref("undefined")}}.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p><code>forEach()</code> executa o <code>callback</code> fornecido uma vez para cada elemento presente no vetor (array) por ordem ascendente. Não é invocado para indices de propriedades que foram apagadas ou que não foram inicializadas (ou seja em sparse arrays).</p>
-
-<p><code>callback</code> é invocado com <strong>três argumentos</strong>:</p>
-
-<ul>
- <li>o <strong>valor do elemento</strong></li>
- <li>o <strong>índice do elemento</strong></li>
- <li>o <strong>vetor (array) que está a ser percorrido</strong></li>
-</ul>
-
-<p>If a <code>thisArg</code> parameter is provided to <code>forEach()</code>, it will be used as callback's <code>this</code> value.  Otherwise, the value {{jsxref("undefined")}} will be used as its <code>this</code> value. The <code>this</code> value ultimately observable by <code>callback</code> is determined according to <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">the usual rules for determining the <code>this</code> seen by a function</a>.</p>
-
-<p>The range of elements processed by <code>forEach()</code> is set before the first invocation of <code>callback</code>. Elements that are appended to the array after the call to <code>forEach()</code> begins will not be visited by <code>callback</code>. If the values of existing elements of the array are changed, the value passed to <code>callback</code> will be the value at the time <code>forEach()</code> visits them; elements that are deleted before being visited are not visited. If elements that are already visited are removed (e.g. using {{jsxref("Array.prototype.shift()", "shift()")}}) during the iteration, later elements will be skipped - see example below.</p>
-
-<p><code>forEach()</code> executes the <code>callback</code> function once for each array element; unlike {{jsxref("Array.prototype.map()", "map()")}} or {{jsxref("Array.prototype.reduce()", "reduce()")}} it always returns the value {{jsxref("undefined")}} and is not chainable. The typical use case is to execute side effects at the end of a chain.</p>
-
-<p><code>forEach()</code> does not mutate the array on which it is called (although <code>callback</code>, if invoked, may do so).</p>
-
-<div class="note">
-<p>There is no way to stop or break a <code>forEach()</code> loop other than by throwing an exception. If you need such behavior, the <code>forEach()</code> method is the wrong tool.</p>
-
-<p>Early termination may be accomplished with:</p>
-
-<ul>
- <li>A simple loop</li>
- <li>A <a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/for...of">for...of</a> loop</li>
- <li>{{jsxref("Array.prototype.every()")}}</li>
- <li>{{jsxref("Array.prototype.some()")}}</li>
- <li>{{jsxref("Array.prototype.find()")}}</li>
- <li>{{jsxref("Array.prototype.findIndex()")}}</li>
-</ul>
-
-<p>The other Array methods: {{jsxref("Array.prototype.every()", "every()")}}, {{jsxref("Array.prototype.some()", "some()")}}, {{jsxref("Array.prototype.find()", "find()")}}, and {{jsxref("Array.prototype.findIndex()", "findIndex()")}} test the array elements with a predicate returning a truthy value to determine if further iteration is required.</p>
-</div>
-
-<h2 id="Examples">Examples</h2>
-
-<h3 id="Converting_a_for_loop_to_forEach">Converting a for loop to forEach</h3>
-
-<p>before</p>
-
-<pre class="brush:js">const items = ['item1', 'item2', 'item3'];
-const copy = [];
-
-for (let i=0; i&lt;items.length; i++) {
-  copy.push(items[i])
-}
-</pre>
-
-<p>after</p>
-
-<pre class="brush:js">const items = ['item1', 'item2', 'item3'];
-const copy = [];
-
-items.forEach(function(item){
-  copy.push(item)
-});
-
-</pre>
-
-<p> </p>
-
-<h3 id="Printing_the_contents_of_an_Array_Object">Printing the contents of an Array Object</h3>
-
-<p>The following code logs a line for each element in an array:</p>
-
-<pre class="brush:js">var userInfo = [{
-  name: "Mayank",
-  age: 30
-}, {
-  name: Meha,
-  age: 26
-}];
-
-userInfo.forEach(function(employee) {
-  console.log(employee.name)
-});
-</pre>
-
-<p> </p>
-
-<p> </p>
-
-<p> </p>
-
-<h3 id="Printing_the_contents_of_an_array">Printing the contents of an array</h3>
-
-<p>The following code logs a line for each element in an array:</p>
-
-<pre class="brush:js">function logArrayElements(element, index, array) {
-  console.log('a[' + index + '] = ' + element);
-}
-
-// Notice that index 2 is skipped since there is no item at
-// that position in the array.
-[2, 5, , 9].forEach(logArrayElements);
-// logs:
-// a[0] = 2
-// a[1] = 5
-// a[3] = 9
-</pre>
-
-<h3 id="Using_thisArg">Using <code>thisArg</code></h3>
-
-<p>The following (contrived) example updates an object's properties from each entry in the array:</p>
-
-<pre class="brush:js">function Counter() {
-  this.sum = 0;
-  this.count = 0;
-}
-Counter.prototype.add = function(array) {
-  array.forEach(function(entry) {
-    this.sum += entry;
-    ++this.count;
-  }, this);
-  // ^---- Note
-};
-
-const obj = new Counter();
-obj.add([2, 5, 9]);
-obj.count;
-// 3
-obj.sum;
-// 16
-</pre>
-
-<p>Since the <code>thisArg</code> parameter (<code>this</code>) is provided to <code>forEach()</code>, it is passed to <code>callback</code> each time it's invoked, for use as its <code>this</code> value.</p>
-
-<div class="note">
-<p>If passing the function argument using an <a href="/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions">arrow function expression</a> the <code>thisArg</code> parameter can be omitted as arrow functions lexically bind the {{jsxref("Operators/this", "this")}} value.</p>
-</div>
-
-<h3 id="An_object_copy_function">An object copy function</h3>
-
-<p>The following code creates a copy of a given object. There are different ways to create a copy of an object; the following is just one way and is presented to explain how <code>Array.prototype.forEach()</code> works by using ECMAScript 5 <code>Object.*</code> meta property functions.</p>
-
-<pre class="brush: js">function copy(obj) {
-  const copy = Object.create(Object.getPrototypeOf(obj));
-  const propNames = Object.getOwnPropertyNames(obj);
-
-  propNames.forEach(function(name) {
-    const desc = Object.getOwnPropertyDescriptor(obj, name);
-    Object.defineProperty(copy, name, desc);
-  });
-
-  return copy;
-}
-
-const obj1 = { a: 1, b: 2 };
-const obj2 = copy(obj1); // obj2 looks like obj1 now
-</pre>
-
-<h3 id="If_the_array_is_modified_during_iteration_other_elements_might_be_skipped.">If the array is modified during iteration, other elements might be skipped.</h3>
-
-<p>The following example logs "one", "two", "four". When the entry containing the value "two" is reached, the first entry of the whole array is shifted off, which results in all remaining entries moving up one position. Because element "four" is now at an earlier position in the array, "three" will be skipped. <code>forEach()</code> does not make a copy of the array before iterating.</p>
-
-<pre class="brush:js">var words = ['one', 'two', 'three', 'four'];
-words.forEach(function(word) {
-  console.log(word);
-  if (word === 'two') {
-    words.shift();
-  }
-});
-// one
-// two
-// four
-</pre>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<p><code>forEach()</code> was added to the ECMA-262 standard in the 5th edition; as such it may not be present in other implementations of the standard. You can work around this by inserting the following code at the beginning of your scripts, allowing use of <code>forEach()</code> in implementations that don't natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming {{jsxref("Object")}} and {{jsxref("TypeError")}} have their original values and that <code>callback.call()</code> evaluates to the original value of {{jsxref("Function.prototype.call()")}}.</p>
-
-<pre class="brush: js">// Production steps of ECMA-262, Edition 5, 15.4.4.18
-// Reference: http://es5.github.io/#x15.4.4.18
-if (!Array.prototype.forEach) {
-
-  Array.prototype.forEach = function(callback/*, thisArg*/) {
-
-    var T, k;
-
-    if (this == null) {
-      throw new TypeError('this is null or not defined');
-    }
-
-    // 1. Let O be the result of calling toObject() passing the
-    // |this| value as the argument.
-    var O = Object(this);
-
-    // 2. Let lenValue be the result of calling the Get() internal
-    // method of O with the argument "length".
-    // 3. Let len be toUint32(lenValue).
-    var len = O.length &gt;&gt;&gt; 0;
-
-    // 4. If isCallable(callback) is false, throw a TypeError exception.
-    // See: http://es5.github.com/#x9.11
-    if (typeof callback !== 'function') {
-      throw new TypeError(callback + ' is not a function');
-    }
-
-    // 5. If thisArg was supplied, let T be thisArg; else let
-    // T be undefined.
-    if (arguments.length &gt; 1) {
-      T = arguments[1];
-    }
-
-    // 6. Let k be 0.
-    k = 0;
-
-    // 7. Repeat while k &lt; len.
-    while (k &lt; len) {
-
-      var kValue;
-
-      // a. Let Pk be ToString(k).
-      //    This is implicit for LHS operands of the in operator.
-      // b. Let kPresent be the result of calling the HasProperty
-      //    internal method of O with argument Pk.
-      //    This step can be combined with c.
-      // c. If kPresent is true, then
-      if (k in O) {
-
-        // i. Let kValue be the result of calling the Get internal
-        // method of O with argument Pk.
-        kValue = O[k];
-
-        // ii. Call the Call internal method of callback with T as
-        // the this value and argument list containing kValue, k, and O.
-        callback.call(T, kValue, k, O);
-      }
-      // d. Increase k by 1.
-      k++;
-    }
-    // 8. return undefined.
-  };
-}
-</pre>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4.4.18', 'Array.prototype.forEach')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.foreach', 'Array.prototype.forEach')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Array.forEach")}}</p>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.find()")}}</li>
- <li>{{jsxref("Array.prototype.findIndex()")}}</li>
- <li>{{jsxref("Array.prototype.map()")}}</li>
- <li>{{jsxref("Array.prototype.every()")}}</li>
- <li>{{jsxref("Array.prototype.some()")}}</li>
- <li>{{jsxref("Map.prototype.forEach()")}}</li>
- <li>{{jsxref("Set.prototype.forEach()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/includes/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/includes/index.html
deleted file mode 100644
index 201d4c9526..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/includes/index.html
+++ /dev/null
@@ -1,175 +0,0 @@
----
-title: Array.prototype.includes()
-slug: Web/JavaScript/Reference/Global_Objects/Array/includes
-tags:
-  - Array
-  - JavaScript
-  - Method
-  - Prototype
-  - Reference
-  - polyfill
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/includes
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>includes()</strong></code> determina se um array contém um determinado elemento, devolvendo <code>true</code> ou <code>false</code>. É utilizado o algoritmo sameValueZero para determinar se o elemento especificado foi encontrado.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/array-includes.html")}}</div>
-
-
-
-<h2 id="Syntax">Syntax</h2>
-
-<pre class="syntaxbox"><var>arr</var>.includes(<var>searchElement[</var>, <var>fromIndex]</var>)
-</pre>
-
-<h3 id="Parameters">Parameters</h3>
-
-<dl>
- <dt><code>searchElement</code></dt>
- <dd>The element to search for.</dd>
- <dt><code>fromIndex</code> {{optional_inline}}</dt>
- <dd>The position in this array at which to begin searching for <code>searchElement</code>. A negative value searches from the index of <code>array.length - fromIndex</code> by asc. Defaults to 0.</dd>
-</dl>
-
-<h3 id="Return_value">Return value</h3>
-
-<p>A {{jsxref("Boolean")}}.</p>
-
-<h2 id="Examples">Examples</h2>
-
-<pre class="brush: js">[1, 2, 3].includes(2);     // true
-[1, 2, 3].includes(4);     // false
-[1, 2, 3].includes(3, 3);  // false
-[1, 2, 3].includes(3, -1); // true
-[1, 2, NaN].includes(NaN); // true
-</pre>
-
-<h3 id="fromIndex_is_greater_than_or_equal_to_the_array_length"><code>fromIndex</code> is greater than or equal to the array length</h3>
-
-<p>If <code>fromIndex</code> is greater than or equal to the length of the array, <code>false</code> is returned. The array will not be searched.</p>
-
-<pre class="brush: js">var arr = ['a', 'b', 'c'];
-
-arr.includes('c', 3);   // false
-arr.includes('c', 100); // false</pre>
-
-<h3 id="Computed_index_is_less_than_0">Computed index is less than 0</h3>
-
-<p>If <code>fromIndex</code> is negative, the computed index is calculated to be used as a position in the array at which to begin searching for <code>searchElement</code>. If the computed index is less than 0, the entire array will be searched.</p>
-
-<pre class="brush: js">// array length is 3
-// fromIndex is -100
-// computed index is 3 + (-100) = -97
-
-var arr = ['a', 'b', 'c'];
-
-arr.includes('a', -100); // true
-arr.includes('b', -100); // true
-arr.includes('c', -100); // true</pre>
-
-<h3 id="includes()_used_as_a_generic_method"><code>includes()</code> used as a generic method</h3>
-
-<p><code>includes()</code> method is intentionally generic. It does not require <code>this</code> value to be an Array object, so it can be applied to other kinds of objects (e.g. array-like objects). The example below illustrates <code>includes()</code> method called on the function's <a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a> object.</p>
-
-<pre class="brush: js">(function() {
-  console.log([].includes.call(arguments, 'a')); // true
-  console.log([].includes.call(arguments, 'd')); // false
-})('a','b','c');</pre>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<pre class="brush: js">// https://tc39.github.io/ecma262/#sec-array.prototype.includes
-if (!Array.prototype.includes) {
-  Object.defineProperty(Array.prototype, 'includes', {
-    value: function(searchElement, fromIndex) {
-
-      if (this == null) {
-        throw new TypeError('"this" is null or not defined');
-      }
-
-      // 1. Let O be ? ToObject(this value).
-      var o = Object(this);
-
-      // 2. Let len be ? ToLength(? Get(O, "length")).
-      var len = o.length &gt;&gt;&gt; 0;
-
-      // 3. If len is 0, return false.
-      if (len === 0) {
-        return false;
-      }
-
-      // 4. Let n be ? ToInteger(fromIndex).
-      //    (If fromIndex is undefined, this step produces the value 0.)
-      var n = fromIndex | 0;
-
-      // 5. If n ≥ 0, then
-      //  a. Let k be n.
-      // 6. Else n &lt; 0,
-      //  a. Let k be len + n.
-      //  b. If k &lt; 0, let k be 0.
-      var k = Math.max(n &gt;= 0 ? n : len - Math.abs(n), 0);
-
-      function sameValueZero(x, y) {
-        return x === y || (typeof x === 'number' &amp;&amp; typeof y === 'number' &amp;&amp; isNaN(x) &amp;&amp; isNaN(y));
-      }
-
-      // 7. Repeat, while k &lt; len
-      while (k &lt; len) {
-        // a. Let elementK be the result of ? Get(O, ! ToString(k)).
-        // b. If SameValueZero(searchElement, elementK) is true, return true.
-        if (sameValueZero(o[k], searchElement)) {
-          return true;
-        }
-        // c. Increase k by 1.
-        k++;
-      }
-
-      // 8. Return false
-      return false;
-    }
-  });
-}
-</pre>
-
-<p>If you need to support truly obsolete JavaScript engines that don't support <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/defineProperty">Object.defineProperty</a></code>, it's best not to polyfill <code>Array.prototype</code> methods at all, as you can't make them non-enumerable.</p>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES7', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td>
-   <td>{{Spec2('ES7')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.includes', 'Array.prototype.includes')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Array.includes")}}</p>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("TypedArray.prototype.includes()")}}</li>
- <li>{{jsxref("String.prototype.includes()")}}</li>
- <li>{{jsxref("Array.prototype.indexOf()")}}</li>
- <li>{{jsxref("Array.prototype.find()")}}</li>
- <li>{{jsxref("Array.prototype.findIndex()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/index.html
deleted file mode 100644
index 5f26f41549..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/index.html
+++ /dev/null
@@ -1,440 +0,0 @@
----
-title: Array
-slug: Web/JavaScript/Reference/Global_Objects/Array
-tags:
-  - Array
-  - Class
-  - Exemplo
-  - Global Objects
-  - JavaScript
-  - Referencia
-  - 'l10n:priority'
-translation_of: Web/JavaScript/Reference/Global_Objects/Array
----
-<div>{{JSRef}}</div>
-
-<p>A classe de JavaScript <strong><code>Array</code></strong> é um objecto global que é utilizado na construção de matrizes; que são objectos de alto nível, semelhantes a listas.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Arrays são objectos em forma de lista, cujo protótipo tem métodos para realizar operações de travessia e mutação. Nem o comprimento de uma array JavaScript nem os tipos dos seus elementos são fixos. Uma vez que o comprimento de uma array pode mudar a qualquer momento, e os dados podem ser armazenados em locais não contíguos da array, não é garantido que uma array JavaScript seja densa; isto depende de como o programador opta por usá-las. Em geral, estas são características convenientes; mas se estas características não forem desejáveis para seu uso particular, você pode considerar o uso de arrays tipadas.</p>
-
-<p>Uma array não pode utilizar strings como índices de elementos (como num {{InterWiki("wikipedia", "Vetor_associativo", "array associativa")}}), deve utilizar números inteiros. A definição ou acesso através de não-inteiros usando notação de parênteses (ou notação de pontos) não definirá ou recuperará um elemento da própria lista da array, mas definirá ou acessará uma variável associada à <a href="pt-PT/docs/Web/JavaScript/Estruturas_de_dados#Objetos">coleção de propriedades dessa array</a>. As propriedades da array e a lista de elementos do mesmo são separadas, e as operações de translação e mutação da array não podem ser aplicadas a essas propriedades com nome.</p>
-
-<p><strong>Criar uma Array</strong></p>
-
-<pre class="brush: js notranslate">var fruits = ['Apple', 'Banana'];
-
-console.log(fruits.length);
-// 2
-</pre>
-
-<p><strong>Aceder (através de índice) item<span class="original-content"> da </span>Array</strong></p>
-
-<pre class="brush: js notranslate">var first = fruits[0];
-// Apple
-
-var last = fruits[fruits.length - 1];
-// Banana
-</pre>
-
-<p><strong>Loop over an Array</strong></p>
-
-<pre class="brush: js notranslate">fruits.forEach(function(item, index, array) {
-  console.log(item, index);
-});
-// Apple 0
-// Banana 1
-</pre>
-
-<p><strong>Adicionar um item ao fim da Array</strong></p>
-
-<pre class="brush: js notranslate">var newLength = fruits.push('Orange');
-// ["Apple", "Banana", "Orange"]
-</pre>
-
-<p><strong>Remover um item do fim da Array</strong></p>
-
-<pre class="brush: js notranslate">var last = fruits.pop(); // remove Orange (from the end)
-// ["Apple", "Banana"];
-</pre>
-
-<p><strong>Remover um item do início da Array</strong></p>
-
-<pre class="brush: js notranslate">var first = fruits.shift(); // remove Apple from the front
-// ["Banana"];
-</pre>
-
-<p><strong>Ad</strong><strong>icionar um item ao início da Array</strong></p>
-
-<pre class="brush: js notranslate">var newLength = fruits.unshift('Strawberry') // add to the front
-// ["Strawberry", "Banana"];
-</pre>
-
-<p><strong>Encontrar o índice dum item na Array</strong></p>
-
-<pre class="brush: js notranslate">fruits.push('Mango');
-// ["Strawberry", "Banana", "Mango"]
-
-var pos = fruits.indexOf('Banana');
-// 1
-</pre>
-
-<p><strong>Remover um item pela posição do índice</strong></p>
-
-<pre class="brush: js notranslate">var removedItem = fruits.splice(pos, 1); // this is how to remove an item
-
-// ["Strawberry", "Mango"]</pre>
-
-<p><strong>Remover items pela posição do índice</strong></p>
-
-<pre class="brush: js notranslate">var vegetables = ['Cabbage', 'Turnip', 'Radish', 'Carrot'];
-console.log(vegetables);
-// ["Cabbage", "Turnip", "Radish", "Carrot"]
-
-var pos = 1, n = 2;
-
-var removedItems = vegetables.splice(pos, n);
-// this is how to remove items, n defines the number of items to be removed,
-// from that position(pos) onward to the end of array.
-
-console.log(vegetables);
-// ["Cabbage", "Carrot"] (the original array is changed)
-
-console.log(removedItems);
-// ["Turnip", "Radish"]</pre>
-
-<p><strong>Copiar uma Array</strong></p>
-
-<pre class="brush: js notranslate">var shallowCopy = fruits.slice(); // this is how to make a copy
-// ["Strawberry"]
-</pre>
-
-<h3 id="Como_aceder_a_elementos_da_array">Como aceder a elementos da array</h3>
-
-<p>JavaScript arrays are zero-indexed: the first element of an array is at index <code>0</code>, and the last element is at the index equal to the value of the array's {{jsxref("Array.length", "length")}} property minus 1.</p>
-
-<pre class="brush: js notranslate">var arr = ['this is the first element', 'this is the second element'];
-console.log(arr[0]);              // logs 'this is the first element'
-console.log(arr[1]);              // logs 'this is the second element'
-console.log(arr[arr.length - 1]); // logs 'this is the second element'
-</pre>
-
-<p>Array elements are object properties in the same way that <code>toString</code> is a property, but trying to access an element of an array as follows throws a syntax error, because the property name is not valid:</p>
-
-<pre class="brush: js notranslate">console.log(arr.0); // a syntax error
-</pre>
-
-<p>There is nothing special about JavaScript arrays and the properties that cause this. JavaScript properties that begin with a digit cannot be referenced with dot notation; and must be accessed using bracket notation. For example, if you had an object with a property named <code>'3d'</code>, it can only be referenced using bracket notation. E.g.:</p>
-
-<pre class="brush: js notranslate">var years = [1950, 1960, 1970, 1980, 1990, 2000, 2010];
-console.log(years.0);   // a syntax error
-console.log(years[0]);  // works properly
-</pre>
-
-<pre class="brush: js notranslate">renderer.3d.setTexture(model, 'character.png');     // a syntax error
-renderer['3d'].setTexture(model, 'character.png');  // works properly
-</pre>
-
-<p>Note that in the <code>3d</code> example, <code>'3d'</code> had to be quoted. It's possible to quote the JavaScript array indexes as well (e.g., <code>years['2']</code> instead of <code>years[2]</code>), although it's not necessary. The 2 in <code>years[2]</code> is coerced into a string by the JavaScript engine through an implicit <code>toString</code> conversion. It is for this reason that <code>'2'</code> and <code>'02'</code> would refer to two different slots on the <code>years</code> object and the following example could be <code>true</code>:</p>
-
-<pre class="brush: js notranslate">console.log(years['2'] != years['02']);
-</pre>
-
-<p>Similarly, object properties which happen to be reserved words(!) can only be accessed as string literals in bracket notation(but it can be accessed by dot notation in firefox 40.0a2 at least):</p>
-
-<pre class="brush: js notranslate">var promise = {
-  'var'  : 'text',
-  'array': [1, 2, 3, 4]
-};
-
-console.log(promise['var']);
-</pre>
-
-<h3 id="Relationship_between_length_and_numerical_properties">Relationship between <code>length</code> and numerical properties</h3>
-
-<p>A JavaScript array's {{jsxref("Array.length", "length")}} property and numerical properties are connected. Several of the built-in array methods (e.g., {{jsxref("Array.join", "join")}}, {{jsxref("Array.slice", "slice")}}, {{jsxref("Array.indexOf", "indexOf")}}, etc.) take into account the value of an array's {{jsxref("Array.length", "length")}} property when they're called. Other methods (e.g., {{jsxref("Array.push", "push")}}, {{jsxref("Array.splice", "splice")}}, etc.) also result in updates to an array's {{jsxref("Array.length", "length")}} property.</p>
-
-<pre class="brush: js notranslate">var fruits = [];
-fruits.push('banana', 'apple', 'peach');
-
-console.log(fruits.length); // 3
-</pre>
-
-<p>When setting a property on a JavaScript array when the property is a valid array index and that index is outside the current bounds of the array, the engine will update the array's {{jsxref("Array.length", "length")}} property accordingly:</p>
-
-<pre class="brush: js notranslate">fruits[5] = 'mango';
-console.log(fruits[5]); // 'mango'
-console.log(Object.keys(fruits));  // ['0', '1', '2', '5']
-console.log(fruits.length); // 6
-</pre>
-
-<p>Increasing the {{jsxref("Array.length", "length")}}.</p>
-
-<pre class="brush: js notranslate">fruits.length = 10;
-console.log(Object.keys(fruits)); // ['0', '1', '2', '5']
-console.log(fruits.length); // 10
-</pre>
-
-<p>Decreasing the {{jsxref("Array.length", "length")}} property does, however, delete elements.</p>
-
-<pre class="brush: js notranslate">fruits.length = 2;
-console.log(Object.keys(fruits)); // ['0', '1']
-console.log(fruits.length); // 2
-</pre>
-
-<p>This is explained further on the {{jsxref("Array.length")}} page.</p>
-
-<h3 id="Creating_an_array_using_the_result_of_a_match">Creating an array using the result of a match</h3>
-
-<p>The result of a match between a regular expression and a string can create a JavaScript array. This array has properties and elements which provide information about the match. Such an array is returned by {{jsxref("RegExp.exec")}}, {{jsxref("String.match")}}, and {{jsxref("String.replace")}}. To help explain these properties and elements, look at the following example and then refer to the table below:</p>
-
-<pre class="brush: js notranslate">// Match one d followed by one or more b's followed by one d
-// Remember matched b's and the following d
-// Ignore case
-
-var myRe = /d(b+)(d)/i;
-var myArray = myRe.exec('cdbBdbsbz');
-</pre>
-
-<p>The properties and elements returned from this match are as follows:</p>
-
-<table class="fullwidth-table">
- <tbody>
-  <tr>
-   <td class="header">Property/Element</td>
-   <td class="header">Description</td>
-   <td class="header">Example</td>
-  </tr>
-  <tr>
-   <td><code>input</code></td>
-   <td>A read-only property that reflects the original string against which the regular expression was matched.</td>
-   <td>cdbBdbsbz</td>
-  </tr>
-  <tr>
-   <td><code>index</code></td>
-   <td>A read-only property that is the zero-based index of the match in the string.</td>
-   <td>1</td>
-  </tr>
-  <tr>
-   <td><code>[0]</code></td>
-   <td>A read-only element that specifies the last matched characters.</td>
-   <td>dbBd</td>
-  </tr>
-  <tr>
-   <td><code>[1], ...[n]</code></td>
-   <td>Read-only elements that specify the parenthesized substring matches, if included in the regular expression. The number of possible parenthesized substrings is unlimited.</td>
-   <td>[1]: bB<br>
-    [2]: d</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Properties">Properties</h2>
-
-<dl>
- <dt><code>Array.length</code></dt>
- <dd>The <code>Array</code> constructor's length property whose value is 1.</dd>
- <dt>{{jsxref("Array.@@species", "get Array[@@species]")}}</dt>
- <dd>The constructor function that is used to create derived objects.</dd>
- <dt>{{jsxref("Array.prototype")}}</dt>
- <dd>Allows the addition of properties to all array objects.</dd>
-</dl>
-
-<h2 id="Methods">Methods</h2>
-
-<dl>
- <dt>{{jsxref("Array.from()")}}</dt>
- <dd>Creates a new <code>Array</code> instance from an array-like or iterable object.</dd>
- <dt>{{jsxref("Array.isArray()")}}</dt>
- <dd>Returns true if a variable is an array, if not false.</dd>
- <dt>{{jsxref("Array.of()")}}</dt>
- <dd>Creates a new <code>Array</code> instance with a variable number of arguments, regardless of number or type of the arguments.</dd>
-</dl>
-
-<h2 id="Array_instances"><code>Array</code> instances</h2>
-
-<p>All <code>Array</code> instances inherit from {{jsxref("Array.prototype")}}. The prototype object of the <code>Array</code> constructor can be modified to affect all <code>Array</code> instances.</p>
-
-<h3 id="Properties_2">Properties</h3>
-
-<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Properties')}}</div>
-
-<h3 id="Methods_2">Methods</h3>
-
-<h4 id="Mutator_methods">Mutator methods</h4>
-
-<div>{{page('en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Mutator_methods')}}</div>
-
-<h4 id="Accessor_methods">Accessor methods</h4>
-
-<div>{{page('en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Accessor_methods')}}</div>
-
-<h4 id="Iteration_methods">Iteration methods</h4>
-
-<div>{{page('en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/prototype', 'Iteration_methods')}}</div>
-
-<h2 id="Array_generic_methods"><code>Array</code> generic methods</h2>
-
-<div class="warning">
-<p><strong>Array generics are non-standard, deprecated and will get removed in the near future</strong>. </p>
-</div>
-
-<p>Sometimes you would like to apply array methods to strings or other array-like objects (such as function {{jsxref("Functions/arguments", "arguments", "", 1)}}). By doing this, you treat a string as an array of characters (or otherwise treat a non-array as an array). For example, in order to check that every character in the variable <var>str</var> is a letter, you would write:</p>
-
-<pre class="brush: js notranslate">function isLetter(character) {
-  return character &gt;= 'a' &amp;&amp; character &lt;= 'z';
-}
-
-if (Array.prototype.every.call(str, isLetter)) {
-  console.log("The string '" + str + "' contains only letters!");
-}
-</pre>
-
-<p>This notation is rather wasteful and JavaScript 1.6 introduced a generic shorthand:</p>
-
-<pre class="brush: js notranslate">if (Array.every(str, isLetter)) {
-  console.log("The string '" + str + "' contains only letters!");
-}
-</pre>
-
-<p>{{jsxref("Global_Objects/String", "Generics", "#String_generic_methods", 1)}} are also available on {{jsxref("String")}}.</p>
-
-<p>These are <strong>not</strong> part of ECMAScript standards and they are not supported by non-Gecko browsers. As a standard alternative, you can convert your object to a proper array using {{jsxref("Array.from()")}}; although that method may not be supported in old browsers:</p>
-
-<pre class="brush: js notranslate">if (Array.from(str).every(isLetter)) {
-  console.log("The string '" + str + "' contains only letters!");
-}
-</pre>
-
-<h2 id="Examples">Examples</h2>
-
-<h3 id="Creating_an_array">Creating an array</h3>
-
-<p>The following example creates an array, <code>msgArray</code>, with a length of 0, then assigns values to <code>msgArray[0]</code> and <code>msgArray[99]</code>, changing the length of the array to 100.</p>
-
-<pre class="brush: js notranslate">var msgArray = [];
-msgArray[0] = 'Hello';
-msgArray[99] = 'world';
-
-if (msgArray.length === 100) {
-  console.log('The length is 100.');
-}
-</pre>
-
-<h3 id="Creating_a_two-dimensional_array">Creating a two-dimensional array</h3>
-
-<p>The following creates a chess board as a two dimensional array of strings. The first move is made by copying the 'p' in (6,4) to (4,4). The old position (6,4) is made blank.</p>
-
-<pre class="brush: js notranslate">var board = [
-  ['R','N','B','Q','K','B','N','R'],
-  ['P','P','P','P','P','P','P','P'],
-  [' ',' ',' ',' ',' ',' ',' ',' '],
-  [' ',' ',' ',' ',' ',' ',' ',' '],
-  [' ',' ',' ',' ',' ',' ',' ',' '],
-  [' ',' ',' ',' ',' ',' ',' ',' '],
-  ['p','p','p','p','p','p','p','p'],
-  ['r','n','b','q','k','b','n','r'] ];
-
-console.log(board.join('\n') + '\n\n');
-
-// Move King's Pawn forward 2
-board[4][4] = board[6][4];
-board[6][4] = ' ';
-console.log(board.join('\n'));
-</pre>
-
-<p>Here is the output:</p>
-
-<pre class="eval notranslate">R,N,B,Q,K,B,N,R
-P,P,P,P,P,P,P,P
- , , , , , , ,
- , , , , , , ,
- , , , , , , ,
- , , , , , , ,
-p,p,p,p,p,p,p,p
-r,n,b,q,k,b,n,r
-
-R,N,B,Q,K,B,N,R
-P,P,P,P,P,P,P,P
- , , , , , , ,
- , , , , , , ,
- , , , ,p, , ,
- , , , , , , ,
-p,p,p,p, ,p,p,p
-r,n,b,q,k,b,n,r
-</pre>
-
-<h3 id="Using_an_array_to_tabulate_a_set_of_values">Using an array to tabulate a set of values</h3>
-
-<pre class="brush: js notranslate">values = [];
-for (var x = 0; x &lt; 10; x++){
- values.push([
-  2 ** x,
-  2 * x ** 2
- ])
-};
-console.table(values)</pre>
-
-<p>Results in</p>
-
-<pre class="eval notranslate">0	1	0
-1	2	2
-2	4	8
-3	8	18
-4	16	32
-5	32	50
-6	64	72
-7	128	98
-8	256	128
-9	512	162</pre>
-
-<p>(First column is the (index))</p>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4', 'Array')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>New methods added: {{jsxref("Array.isArray")}}, {{jsxref("Array.prototype.indexOf", "indexOf")}}, {{jsxref("Array.prototype.lastIndexOf", "lastIndexOf")}}, {{jsxref("Array.prototype.every", "every")}}, {{jsxref("Array.prototype.some", "some")}}, {{jsxref("Array.prototype.forEach", "forEach")}}, {{jsxref("Array.prototype.map", "map")}}, {{jsxref("Array.prototype.filter", "filter")}}, {{jsxref("Array.prototype.reduce", "reduce")}}, {{jsxref("Array.prototype.reduceRight", "reduceRight")}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array-objects', 'Array')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>New methods added: {{jsxref("Array.from")}}, {{jsxref("Array.of")}}, {{jsxref("Array.prototype.find", "find")}}, {{jsxref("Array.prototype.findIndex", "findIndex")}}, {{jsxref("Array.prototype.fill", "fill")}}, {{jsxref("Array.prototype.copyWithin", "copyWithin")}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array-objects', 'Array')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>New method added: {{jsxref("Array.prototype.includes()")}}</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_Navegadores">Compatibilidade de Navegadores</h2>
-
-<div class="hidden">A tabela de compatibilidade nesta página é gerada a partir de dados estruturados. Se quiser contribuir para os dados, por favor consulte <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> e envie-nos um pull request.</div>
-
-<p>{{Compat("javascript.builtins.Array")}}</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Indexing_object_properties">JavaScript Guide: “Indexing object properties”</a></li>
- <li><a href="/en-US/docs/Web/JavaScript/Guide/Predefined_Core_Objects#Array_Object">JavaScript Guide: “Predefined Core Objects: <code>Array</code> Object”</a></li>
- <li><a href="/en-US/docs/Web/JavaScript/Reference/Operators/Array_comprehensions">Array comprehensions</a></li>
- <li><a href="https://github.com/plusdude/array-generics">Polyfill for JavaScript 1.8.5 Array Generics and ECMAScript 5 Array Extras</a></li>
- <li><a href="/en-US/docs/JavaScript_typed_arrays">Typed Arrays</a></li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/join/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/join/index.html
deleted file mode 100644
index aec6f34cc2..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/join/index.html
+++ /dev/null
@@ -1,90 +0,0 @@
----
-title: Array.prototype.join()
-slug: Web/JavaScript/Reference/Global_Objects/Array/join
-tags:
-  - JavaScript
-  - Prototipo
-  - Referencia
-  - Vector
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/join
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>join()</strong></code> cria e devolve uma <em>string</em> ao concatenar todos os elementos numa <em>array</em> (ou <a href="/en-US/docs/Web/JavaScript/Guide/Indexed_collections#Working_with_array-like_objects">objeto como um vetor / matriz</a>) numa cadeia separada por vírgulas ou outro separador especificado. Se a <em>array</em> tem um só item, esse item é devolvido sem o uso do separador.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/array-join.html")}}</div>
-
-
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox notranslate"><var>vec</var>.join([<var>separador</var>])</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>separador</code> {{optional_inline}}</dt>
- <dd>Especifica uma <em>string</em> (cadeia de caracteres) para separar cada elemento do vetor. O separador é convertido em cadeia se for necessário. Se for omitido, os elementos serão separados por virgulas (","). Se <code>separador</code> é uma cadeia vazia, todos os elementos são unidos sem qualquer caráter entre eles.</dd>
-</dl>
-
-<h3 id="Resultado">Resultado</h3>
-
-<p>Uma cadeia (de caracteres) com todos os elementos do vetor unidos. Se <code><em>vec</em>.length</code> é <code>0</code>, é devolvida uma cadeia vazia.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>As conversões de todos os elementos do vetor para cadeias (de caracteres) são unidas numa única cadeia.</p>
-
-<p>Caso algum elemento seja <code>undefined</code>, <code>null</code> ou um vetor vazio <code>[]</code>, este será convertido numa cadeia vazia.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Juntar_um_vetor_de_quatro_formas_diferentes">Juntar um vetor de quatro formas diferentes</h3>
-
-<p>O exemplo que se segue cria um vetor, <code>a</code>, com três elementos, depois disso une o vetor quatro vezes: usando o separador predefinido, uma vírgula e um espaço, o símbolo mais, e finalmente uma cadeia (de caracteres) vazia.</p>
-
-<pre class="brush: js notranslate">var a = ['Vento', 'Chuva', 'Fogo'];
-a.join();      // 'Vento,Chuva,Fogo'
-a.join(', ');  // 'Vento, Chuva, Fogo'
-a.join(' + '); // 'Vento + Chuva + Fogo'
-a.join('');    // 'VentoChuvaFogo'</pre>
-
-<h3 id="Juntar_um_objeto_como_vetor">Juntar um objeto como vetor</h3>
-
-<p>O seguinte exemplo junta um objeto como vetor (<code><a href="https://wiki.developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/arguments">arguments</a></code>), ao chamar {{jsxref("Function.prototype.call")}} no <code>Array.prototype.join</code>.</p>
-
-<pre class="brush: js notranslate">function f(a, b, c) {
-  var s = Array.prototype.join.call(arguments);
-  console.log(s); // '<span class="message-body-wrapper"><span class="message-flex-body"><span class="devtools-monospace message-body"><span class="objectBox objectBox-string">1,a,true'</span></span></span></span>
-}
-f(1, 'a', true);
-// valor devolvido: "1,a,true"
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.join', 'Array.prototype.join')}}</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade">Compatibilidade</h2>
-
-
-
-<p>{{Compat("javascript.builtins.Array.join")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.split()")}}</li>
- <li>{{jsxref("Array.prototype.toString()")}}</li>
- <li>{{jsxref("TypedArray.prototype.join()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/map/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/map/index.html
deleted file mode 100644
index 12910ebc2a..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/map/index.html
+++ /dev/null
@@ -1,366 +0,0 @@
----
-title: Array.prototype.map()
-slug: Web/JavaScript/Reference/Global_Objects/Array/map
-tags:
-  - Array
-  - ECMAScript 5
-  - JavaScript
-  - Prototype
-  - Referencia
-  - metodo
-  - polyfill
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/map
----
-<div>{{JSRef}}</div>
-
-<p><span class="seoSummary">O método <code><strong>map()</strong></code> <strong>cria uma nova array</strong> preenchida com os resultados da chamada de uma função fornecida em cada elemento da matriz de chamada.</span></p>
-
-<div>{{EmbedInteractiveExample("pages/js/array-map.html")}}</div>
-
-<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox notranslate">let <var>new_array</var> = <var>arr</var>.map(function <var>callback</var>( <var>currentValue</var>[, <var>index</var>[, <var>array</var>]]) {
-    // retorna novo elemento para new_array
-}[, <var>thisArg</var>])
-</pre>
-
-<h3 id="Parameteros">Parameteros</h3>
-
-<dl>
- <dt><code><var>callback</var></code></dt>
- <dd>
- <p>Função que é chamada para cada elemento de <code>arr</code>. Cada vez que a função <code>callback</code> é executada, o valor devolvido é acrescentado a <code>new_array</code>.</p>
-
- <p>A função <code><var>callback</var></code> aceita os seguintes argumentos:</p>
-
- <dl>
-  <dt><code><var>currentValue</var></code></dt>
-  <dd>O elemento da matriz a ser processado.</dd>
-  <dt><code><var>index</var></code>{{optional_inline}}</dt>
-  <dd>O indice do elemento da matriz a ser processado.</dd>
-  <dt><code><var>array</var></code>{{optional_inline}}</dt>
-  <dd>A matriz em que a função <code>map</code> foi chamada.</dd>
- </dl>
- </dd>
- <dt><code>thisArg</code>{{optional_inline}}</dt>
- <dd>Valor para usar como <code>this</code> ao executar a função <code><var>callback</var></code>.</dd>
-</dl>
-
-<h3 id="Valor_de_retorno">Valor de retorno</h3>
-
-<p>Uma nova matriz em que cada elemento é um resultado da função callback..</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p><code>map</code> chama a função <code><var>callback</var></code> <strong>uma vez por cada elemento</strong> na matriz, por ordem, e cria uma matriz com os resultados. <code><var>callback</var></code> é só chamada nos indices da matriz que têm valores (inclusive {{jsxref("undefined")}}).</p>
-
-<p>Não é chamada para elementos que não pertecem à matriz; isto sendo:</p>
-
-<ul>
- <li>indices que não pertencem pela matriz;</li>
- <li>que foram eliminados; ou</li>
- <li>que nunca tiveram um valor.</li>
-</ul>
-
-<h3 id="Quando_não_usar_map">Quando não usar map()</h3>
-
-<p>Como <code>map</code> map cira uma nova matriz, é um <em>anti-pattern</em> usar a função quando não se vai usar o valor devolvido; use antes {{jsxref("Array/forEach", "forEach")}} ou {{jsxref("for...of", "for-of")}}.</p>
-
-<p>Não deve usar <code>map</code> se:</p>
-
-<ul>
- <li>não vai usar o valor devolvido; e/ou</li>
- <li>o <code>callback</code> não devolve um valor.</li>
-</ul>
-
-<h3 id="Parameteros_em_detalhe">Parameteros em detalhe</h3>
-
-<p><code><var>callback</var></code> é chamada com três argumentos: o valor do elemento, o indice do elemento, e a matriz do objeto a ser mapeado.</p>
-
-<p>Se o parametero <code>thisArg</code> é fornecido, é usado como o valor de <code>this</code> na função <em><code>callback</code></em>. Se não, o valor {{jsxref("undefined")}} é usado como o valor de <code>this</code>. O valor de <code>this</code> no corpo da função <code><var>callback</var></code> é determinado de acordo com <a href="/en-US/docs/Web/JavaScript/Reference/Operators/this">as regras habituais para determinar o valor de this numa função</a>.</p>
-
-<p><code>map</code> não modifica a matriz em que é chamada (embora a função <em><code>callback</code></em>, se invocada, possa fazê-lo).</p>
-
-<p>A série de elementos processados por <code>map</code> é definida antes da primeira invocação de <em><code>callback</code></em>. Os elementos que são anexados ao conjunto após a chamada para <code>map</code> não serão visitados por <code><em>callback</em></code>. Se os elementos existentes da matriz forem alterados, o seu valor como passado para <em><code>callback</code></em> será o valor no momento em que <code>map</code> os visitar. Os elementos que são apagados após a chamada para <code>map</code> começa e antes de serem visitados, não são visitados.</p>
-
-<p>Devido ao algoritmo defenido na especificação, se a matriz em que <code>map</code> é chamada for esparsa, a matriz resultante também o será com os mesmos indices em branco.</p>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<p><code>map</code> was added to the ECMA-262 standard in the 5th edition. Therefore, it may not be present in all implementations of the standard.</p>
-
-<p>You can work around this by inserting the following code at the beginning of your scripts, allowing use of <code>map</code> in implementations which do not natively support it. This algorithm is exactly the one specified in ECMA-262, 5th edition, assuming {{jsxref("Object")}}, {{jsxref("TypeError")}}, and {{jsxref("Array")}} have their original values and that <code>callback.call</code> evaluates to the original value of <code>{{jsxref("Function.prototype.call")}}</code>.</p>
-
-<pre class="brush: js notranslate">// Production steps of ECMA-262, Edition 5, 15.4.4.19
-// Reference: http://es5.github.io/#x15.4.4.19
-if (!Array.prototype.map) {
-
-  Array.prototype.map = function(callback/*, thisArg*/) {
-
-    var T, A, k;
-
-    if (this == null) {
-      throw new TypeError('this is null or not defined');
-    }
-
-    // 1. Let O be the result of calling ToObject passing the |this|
-    //    value as the argument.
-    var O = Object(this);
-
-    // 2. Let lenValue be the result of calling the Get internal
-    //    method of O with the argument "length".
-    // 3. Let len be ToUint32(lenValue).
-    var len = O.length &gt;&gt;&gt; 0;
-
-    // 4. If IsCallable(callback) is false, throw a TypeError exception.
-    // See: http://es5.github.com/#x9.11
-    if (typeof callback !== 'function') {
-      throw new TypeError(callback + ' is not a function');
-    }
-
-    // 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
-    if (arguments.length &gt; 1) {
-      T = arguments[1];
-    }
-
-    // 6. Let A be a new array created as if by the expression new Array(len)
-    //    where Array is the standard built-in constructor with that name and
-    //    len is the value of len.
-    A = new Array(len);
-
-    // 7. Let k be 0
-    k = 0;
-
-    // 8. Repeat, while k &lt; len
-    while (k &lt; len) {
-
-      var kValue, mappedValue;
-
-      // a. Let Pk be ToString(k).
-      //   This is implicit for LHS operands of the in operator
-      // b. Let kPresent be the result of calling the HasProperty internal
-      //    method of O with argument Pk.
-      //   This step can be combined with c
-      // c. If kPresent is true, then
-      if (k in O) {
-
-        // i. Let kValue be the result of calling the Get internal
-        //    method of O with argument Pk.
-        kValue = O[k];
-
-        // ii. Let mappedValue be the result of calling the Call internal
-        //     method of callback with T as the this value and argument
-        //     list containing kValue, k, and O.
-        mappedValue = callback.call(T, kValue, k, O);
-
-        // iii. Call the DefineOwnProperty internal method of A with arguments
-        // Pk, Property Descriptor
-        // { Value: mappedValue,
-        //   Writable: true,
-        //   Enumerable: true,
-        //   Configurable: true },
-        // and false.
-
-        // In browsers that support Object.defineProperty, use the following:
-        // Object.defineProperty(A, k, {
-        //   value: mappedValue,
-        //   writable: true,
-        //   enumerable: true,
-        //   configurable: true
-        // });
-
-        // For best browser support, use the following:
-        A[k] = mappedValue;
-      }
-      // d. Increase k by 1.
-      k++;
-    }
-
-    // 9. return A
-    return A;
-  };
-}
-</pre>
-
-<h2 id="Examples">Examples</h2>
-
-<h3 id="Mapping_an_array_of_numbers_to_an_array_of_square_roots">Mapping an array of numbers to an array of square roots</h3>
-
-<p>The following code takes an array of numbers and creates a new array containing the square roots of the numbers in the first array.</p>
-
-<pre class="brush: js notranslate">let numbers = [1, 4, 9]
-let roots = numbers.map(function(num) {
-    return Math.sqrt(num)
-})
-// roots is now     [1, 2, 3]
-// numbers is still [1, 4, 9]
-</pre>
-
-<h3 id="Using_map_to_reformat_objects_in_an_array">Using map to reformat objects in an array</h3>
-
-<p>The following code takes an array of objects and creates a new array containing the newly reformatted objects.</p>
-
-<pre class="brush: js notranslate">let kvArray = [{key: 1, value: 10},
-               {key: 2, value: 20},
-               {key: 3, value: 30}]
-
-let reformattedArray = kvArray.map(obj =&gt; {
-   let rObj = {}
-   rObj[obj.key] = obj.value
-   return rObj
-})
-// reformattedArray is now [{1: 10}, {2: 20}, {3: 30}],
-
-// kvArray is still:
-// [{key: 1, value: 10},
-//  {key: 2, value: 20},
-//  {key: 3, value: 30}]
-</pre>
-
-<h3 id="Mapping_an_array_of_numbers_using_a_function_containing_an_argument">Mapping an array of numbers using a function containing an argument</h3>
-
-<p>The following code shows how <code>map</code> works when a function requiring one argument is used with it. The argument will automatically be assigned from each element of the array as <code>map</code> loops through the original array.</p>
-
-<pre class="brush: js notranslate">let numbers = [1, 4, 9]
-let doubles = numbers.map(function(num) {
-  return num * 2
-})
-
-// doubles is now   [2, 8, 18]
-// numbers is still [1, 4, 9]
-</pre>
-
-<h3 id="Using_map_generically">Using map generically</h3>
-
-<p>This example shows how to use map on a {{jsxref("String")}} to get an array of bytes in the ASCII encoding representing the character values:</p>
-
-<pre class="brush: js notranslate">let map = Array.prototype.map
-let a = map.call('Hello World', function(x) {
-  return x.charCodeAt(0)
-})
-// a now equals [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]
-</pre>
-
-<h3 id="Using_map_generically_querySelectorAll">Using map generically querySelectorAll</h3>
-
-<p>This example shows how to iterate through a collection of objects collected by <code>querySelectorAll</code>. This is because <code>querySelectorAll</code> returns a <code>NodeList</code> (which is a collection of objects).</p>
-
-<p>In this case, we return all the selected <code>option</code>s' values on the screen:</p>
-
-<pre class="brush: js notranslate">let elems = document.querySelectorAll('select option:checked')
-let values = Array.prototype.map.call(elems, function(obj) {
-  return obj.value
-})
-</pre>
-
-<p>An easier way would be the {{jsxref("Array.from()")}} method.</p>
-
-<h3 id="Tricky_use_case">Tricky use case</h3>
-
-<p>(<a href="http://www.wirfs-brock.com/allen/posts/166">inspired by this blog post</a>)</p>
-
-<p>It is common to use the callback with one argument (the element being traversed). Certain functions are also commonly used with one argument, even though they take additional optional arguments. These habits may lead to confusing behaviors.</p>
-
-<p>Consider:</p>
-
-<pre class="brush: js notranslate">["1", "2", "3"].map(parseInt)</pre>
-
-<p>While one might expect <code>[1, 2, 3]</code>, the actual result is <code>[1, NaN, NaN]</code>.</p>
-
-<p>{{jsxref("parseInt")}} is often used with one argument, but takes two. The first is an expression and the second is the radix to the callback function, <code>Array.prototype.map</code> passes 3 arguments:</p>
-
-<ul>
- <li>the element</li>
- <li>the index</li>
- <li>the array</li>
-</ul>
-
-<p>The third argument is ignored by {{jsxref("parseInt")}}—but <em>not</em> the second one! This is the source of possible confusion.</p>
-
-<p>Here is a concise example of the iteration steps:</p>
-
-<pre class="brush: js notranslate">// parseInt(string, radix) -&gt; map(parseInt(value, index))
-/*  first iteration  (index is 0): */ parseInt("1", 0)  // 1
-/*  second iteration (index is 1): */ parseInt("2", 1)  // NaN
-/*  third iteration  (index is 2): */ parseInt("3", 2)  // NaN
-</pre>
-
-<p>Then let's talk about solutions.</p>
-
-<pre class="brush: js notranslate">function returnInt(element) {
-  return parseInt(element, 10)
-}
-
-['1', '2', '3'].map(returnInt); // [1, 2, 3]
-// Actual result is an array of numbers (as expected)
-
-// Same as above, but using the concise arrow function syntax
-['1', '2', '3'].map( str =&gt; parseInt(str) )
-
-// A simpler way to achieve the above, while avoiding the "gotcha":
-['1', '2', '3'].map(Number)  // [1, 2, 3]
-
-// But unlike parseInt(), Number() will also return a float or (resolved) exponential notation:
-['1.1', '2.2e2', '3e300'].map(Number)  // [1.1, 220, 3e+300]
-
-// For comparison, if we use parseInt() on the array above:
-['1.1', '2.2e2', '3e300'].map( str =&gt; parseInt(str) ) // [1, 2, 3]
-</pre>
-
-<p>One alternative output of the map method being called with {{jsxref("parseInt")}} as a parameter runs as follows:</p>
-
-<pre class="brush: js notranslate">let xs = ['10', '10', '10']
-
-xs = xs.map(parseInt)
-
-console.log(xs)
-// Actual result of 10,NaN,2 may be unexpected based on the above description.</pre>
-
-<h3 id="Mapped_array_contains_undefined">Mapped array contains undefined</h3>
-
-<p>When {{jsxref("undefined")}} or nothing is returned:</p>
-
-<pre class="brush: js notranslate">let numbers = [1, 2, 3, 4]
-let filteredNumbers = numbers.map(function(num, index) {
-  if (index &lt; 3) {
-     return num
-  }
-})
-// index goes from 0, so the filterNumbers are 1,2,3 and undefined.
-// filteredNumbers is [1, 2, 3, undefined]
-// numbers is still [1, 2, 3, 4]
-
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Especificação</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.map', 'Array.prototype.map')}}</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade">Compatibilidade</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Array.map")}}</p>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.forEach()")}}</li>
- <li>{{jsxref("Map")}} object</li>
- <li>{{jsxref("Array.from()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/pop/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/pop/index.html
deleted file mode 100644
index 440ea3e6ee..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/pop/index.html
+++ /dev/null
@@ -1,96 +0,0 @@
----
-title: Array.prototype.pop()
-slug: Web/JavaScript/Reference/Global_Objects/Array/pop
-tags:
-  - JavaScript
-  - Lista
-  - Prototipo
-  - Referencia
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/pop
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>pop()</strong></code> remove o último elemento de um array e retorna esse elemento. Este método altera o tamanho do array.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/array-pop.html")}}</div>
-
-<h2 id="Syntax">Syntax</h2>
-
-<pre class="syntaxbox"><var>arr</var>.pop()</pre>
-
-<h3 id="Valor_retornado">Valor retornado</h3>
-
-<p>O elemento removido do array; {{jsxref("undefined")}} se o array estiver vazio.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O método <code>pop</code> remove o último elemento de um array e retorna esse elemento para a função que o chamou.</p>
-
-<p><code>pop</code> é um método intencionalmente genérico; este método pode ser {{jsxref("Function.call", "called", "", 1)}} ou {{jsxref("Function.apply", "applied", "", 1)}} para objectos parecidos com arrays. Objectos que não contenham a propriedade <code>length</code> (tamanho) que reflete o último elemento numa lista de consecutivas propriedades numéricas zero-based, pode não se comportar de maneira significativa.</p>
-
-<p><code><font face="Open Sans, arial, x-locale-body, sans-serif"><span style="background-color: #ffffff;">Se o método </span></font>pop()</code> for chamado num array vazio este retorna {{jsxref("undefined")}}.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Remover_o_último_elemento_de_um_array">Remover o último elemento de um array</h3>
-
-<p>O seguinte exemplo cria um array <font face="consolas, Liberation Mono, courier, monospace"><span style="background-color: rgba(220, 220, 220, 0.5);">peixes</span></font> que contêm quatro elementos, e depois remove o último elemento.</p>
-
-<pre class="brush: js">var peixes = ['anjo', 'palhaço', 'mandarim', 'esturjão'];
-
-var popped = peixes.pop();
-
-console.log(peixes); // ['anjo', 'palhaço', 'mandarim']
-
-console.log(popped); // 'esturjão'</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Definição inicial. Implementada no JavaScript 1.2.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4.4.6', 'Array.prototype.pop')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.pop', 'Array.prototype.pop')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade">Compatibilidade</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Array.pop")}}</p>
-</div>
-
-<h2 id="Ver_também">Ver também </h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.push()")}}</li>
- <li>{{jsxref("Array.prototype.shift()")}}</li>
- <li>{{jsxref("Array.prototype.unshift()")}}</li>
- <li>{{jsxref("Array.prototype.concat()")}}</li>
- <li>{{jsxref("Array.prototype.splice()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/reverse/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/reverse/index.html
deleted file mode 100644
index a442018c61..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/reverse/index.html
+++ /dev/null
@@ -1,133 +0,0 @@
----
-title: Array.prototype.reverse()
-slug: Web/JavaScript/Reference/Global_Objects/Array/reverse
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/reverse
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>reverse()</strong></code> inverte um vector (<code>Array</code>). O primeiro elemento torna-se o último, e o último elemento torna-se o primeiro.</p>
-
-<pre class="brush: js">var a = ['um', 'dois', 'três'];
-a.reverse();
-
-console.log(a); // ['três', 'dois', 'um']
-</pre>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><var>a</var>.reverse()</pre>
-
-<h3 id="Valor_devolvido">Valor devolvido</h3>
-
-<p>O vector (<code>Array</code>) invertido.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O método <code>reverse</code> transpõe os elementos do vector que o chamou, mudando o vector, e devolvendo uma referência para o vector.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Invertendo_os_elementos_num_vector">Invertendo os elementos num vector</h3>
-
-<p>O exemplo que se segue cria um vector <code>a</code>, que contém três elementos, e depois o inverte. A chamada a <code>reverse()</code> devolve uma referência para o vector invertido <code>a</code>.</p>
-
-<pre class="brush: js">var a = ['um', 'dois', 'três'];
-var invertido = a.reverse();
-
-console.log(a);        // ['três', 'dois', 'um']
-console.log(invertido); // ['três', 'dois', 'um']
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.4.4.8', 'Array.prototype.reverse')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.reverse', 'Array.prototype.reverse')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Edge</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatChrome("1.0")}}</td>
-   <td>{{CompatGeckoDesktop("1.7")}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatIE("5.5")}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.join()")}}</li>
- <li>{{jsxref("Array.prototype.sort()")}}</li>
- <li>{{jsxref("TypedArray.prototype.reverse()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/array/slice/index.html b/files/pt-pt/web/javascript/reference/global_objects/array/slice/index.html
deleted file mode 100644
index 48820a1ff7..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/array/slice/index.html
+++ /dev/null
@@ -1,154 +0,0 @@
----
-title: Array.prototype.slice()
-slug: Web/JavaScript/Reference/Global_Objects/Array/slice
-tags:
-  - Array
-  - JavaScript
-  - Prototipo
-  - Referencia
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Array/slice
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>slice()</strong></code> devolve uma cópia rasa (é feita uma cópia dos <em>pointers</em> se for um objeto) de uma parte de uma matriz num novo objeto de <code>array</code> selecionado do <code>start</code> (início incluído) ao <code>end</code> (fim excluído) onde o <code>start</code> e o <code>end</code> representam o índice de itens dessa matriz. A matriz original não é modificada.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/array-slice.html")}}</div>
-
-<p class="hidden">The source for this interactive demo is stored in a GitHub repository. If you'd like to contribute to the interactive demo project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox notranslate"><var>arr</var>.slice([<var>start</var>[, <var>end</var>]])
-</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code><var>start</var></code> {{optional_inline}}</dt>
- <dd>Indice de base zero, onde coméça a cópia.</dd>
- <dd>Um índice negativo pode ser utilizado, indicando um intervalo a partir do fim da sequência. <code>slice(-2)</code> extrai os dois últimos elementos da sequência.</dd>
- <dd>Se <code><var>start</var></code> é undefined, <code>slice</code> coméça a partir do indice <code>0</code>.</dd>
- <dd>Se <code><var>start</var></code> é maior que o último índice da sequência, uma matriz vazia é devolvida.</dd>
- <dt><code><var>end</var></code> {{optional_inline}}</dt>
- <dd>Índice antes do qual se deve terminar a extração. <code>slice</code> extrai até o valor de indice <code>end</code>, mas sem incluir <code>end</code>. Por exemplo, <code>slice(1,4)</code> extrai do segundo até ao quarto elemento (elementos indexados 1, 2, e 3).</dd>
- <dd>Pode ser utilizado um índice negativo, indicando o último índice a partir do fim da sequência. <code>slice(2,-1)</code> extrai do terceiro até ao penúltimo elemento na sequência.</dd>
- <dd>Se <code>end</code> é omisso, <code>slice</code> extrai todos os elementos até ao fim da sequência (<code>arr.length</code>).</dd>
- <dd>Se <code>end</code> é maior que o comprimento da sequência, <code>slice</code> extrai todos os elementos até ao fim da sequência (<code>arr.length</code>).</dd>
-</dl>
-
-<h3 id="Resultado">Resultado</h3>
-
-<p>Uma matriz nova contendo os elementos extraídos.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p><code>slice</code> não altera a matriz original. Devolve uma cópia rasa dos elementos da matriz original. Os elementos da matriz original são copiados para a matriz devolvida como se segue:</p>
-
-<ul>
- <li>Para referências de objectos (e não o objecto real), <code>slice</code> copia as referências de objectos para a nova matriz. Tanto o original como a nova matriz referem-se ao mesmo objecto. Se um objecto referenciado mudar, as mudanças são visíveis tanto para a nova matriz como para a original.</li>
- <li>Para strings, números e booleanos (não {{jsxref("String")}}, {{jsxref("Number")}} e {{jsxref("Booleano")}} objetos), <code>slice</code> copia os valores para a nova matriz. Alterações à string, número, ou booleano numa matriz não afetam a outra matriz.</li>
-</ul>
-
-<p>Se um novo elemento é adicionado a qualquer das matrizes, a outra matriz não é afetada.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Devolver_uma_porção_duma_matriz">Devolver uma porção duma matriz</h3>
-
-<pre class="brush: js notranslate">let fruits = ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
-let citrus = fruits.slice(1, 3)
-
-// fruits contêm ['Banana', 'Orange', 'Lemon', 'Apple', 'Mango']
-// citrus contêm ['Orange','Lemon']
-</pre>
-
-<h3 id="Usar_slice">Usar <code>slice</code></h3>
-
-<p>No seguinte exemplo, <code>slice</code> cria uma <em>array</em> (matriz), <code>newCar</code>, a partir de <code>myCar</code>. Ambos incluem uma referência ao objeto <code>myHonda</code>. Quando a propriedade <em>color</em> (cor) de <code>myHonda</code> é mudada para <em>purple</em> (roxo), ambas matrizes refletem a alteração.</p>
-
-<pre class="brush: js notranslate">// Usando slice, cria newCar a partir de myCar.
-let myHonda = { color: 'red', wheels: 4, engine: { cylinders: 4, size: 2.2 } }
-let myCar = [myHonda, 2, 'cherry condition', 'purchased 1997']
-let newCar = myCar.slice(0, 2)
-
-// Imprime os valors de myCar, newCar, a propriadade
-// color de myHonda em ambas arrays.
-console.log('myCar = ' + JSON.stringify(myCar))
-console.log('newCar = ' + JSON.stringify(newCar))
-console.log('myCar[0].color = ' + myCar[0].color)
-console.log('newCar[0].color = ' + newCar[0].color)
-
-// Mude a propriadade color de myHonda.
-myHonda.color = 'purple'
-console.log('A nova cor de my Honda é ' + myHonda.color)
-
-// Imprime a propriadade color de myHonda em ambas arrays.
-console.log('myCar[0].color = ' + myCar[0].color)
-console.log('newCar[0].color = ' + newCar[0].color)
-</pre>
-
-<p>Este <em>script</em> imprime:</p>
-
-<pre class="notranslate">myCar = [{color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}}, 2,
-         'cherry condition', 'purchased 1997']
-newCar = [{color: 'red', wheels: 4, engine: {cylinders: 4, size: 2.2}}, 2]
-myCar[0].color = red
-newCar[0].color = red
-A nova cor de my Honda é purple
-myCar[0].color = purple
-newCar[0].color = purple
-</pre>
-
-<h3 id="Objetos_parecidos_com_Array">Objetos parecidos com Array</h3>
-
-<p>O método <code>slice</code> tembém pode ser chamado para converter objetos / coleções do estilo matriz para um objeto <code>Array</code>. É só preciso {{jsxref("Function.prototype.bind", "<em>bind</em>")}} o método ao objeto. Os {{jsxref("Functions/arguments", "argumentos")}} dentro da função são um exemplo de um "objeto de estilo matriz".</p>
-
-<pre class="brush: js notranslate">function list() {
-  return Array.prototype.slice.call(arguments)
-}
-
-let list1 = list(1, 2, 3) // [1, 2, 3]
-</pre>
-
-<p><em>Binding</em> pode ser feito com o método {{jsxref("Function.prototype.call", "call()")}} de {{jsxref("Function.prototype")}} e também pode ser simplificado a usar  <code>[].slice.call(arguments)</code> invés de <code>Array.prototype.slice.call</code>.</p>
-
-<p>Pode ser simplificado a usar {{jsxref("Function.prototype.bind", "bind")}}.</p>
-
-<pre class="brush: js notranslate">let unboundSlice = Array.prototype.slice
-let slice = Function.prototype.call.bind(unboundSlice)
-
-function list() {
-  return slice(arguments)
-}
-
-let list1 = list(1, 2, 3) // [1, 2, 3]</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Especificação</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-array.prototype.slice', 'Array.prototype.slice')}}</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade">Compatibilidade</h2>
-
-
-
-<p>{{Compat("javascript.builtins.Array.slice")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Array.prototype.splice()")}}</li>
- <li>{{jsxref("Function.prototype.call()")}}</li>
- <li>{{jsxref("Function.prototype.bind()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/arraybuffer/index.html b/files/pt-pt/web/javascript/reference/global_objects/arraybuffer/index.html
deleted file mode 100644
index c612f44b26..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/arraybuffer/index.html
+++ /dev/null
@@ -1,219 +0,0 @@
----
-title: ArrayBuffer
-slug: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
-translation_of: Web/JavaScript/Reference/Global_Objects/ArrayBuffer
----
-<div>{{JSRef}}</div>
-
-<div><strong><code>ArrayBuffer </code></strong>é um objeto utilizado para representar um buffer de dados em binário de tamanho pré-definido. Não é possivel manipular o conteudo do buffer diretamente; em vez disso, tem de se criar um dos <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">typed array objects</a> ou um objeto {{jsxref("DataView")}} que representa um buffer num formato especifico, e usa-o para ler e escrever  o conteudo do buffer. </div>
-
-<div> </div>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox">new ArrayBuffer(length)
-</pre>
-
-<h3 id="Parametros">Parametros</h3>
-
-<dl>
- <dt><code>length</code></dt>
- <dd>O tamanho, em bytes, do array buffer que se pretende criar.</dd>
-</dl>
-
-<h3 id="Retorno">Retorno</h3>
-
-<p> Um novo objecto do tipo <code>ArrayBuffer</code> do tamanho especificado. O respetivo conteudo é inicializado a 0.</p>
-
-<h3 id="Excepções">Excepções</h3>
-
-<p>A {{jsxref("RangeError")}} é lançada caso o tamanho (<code>length) </code>é maior do que<code> </code>{{jsxref("Number.MAX_SAFE_INTEGER")}} (&gt;= 2 ** 53) ou caso seja negativo.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O construtor de <code>ArrayBuffer</code> cria um novo objeto do tipo <code>ArrayBuffer</code> com o tamanho especificado em bytes.</p>
-
-<h3 id="Obter_um_array_buffer_a_partir_de_dados_existentes">Obter um array buffer a partir de dados existentes</h3>
-
-<ul>
- <li><a href="/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Appendix.3A_Decode_a_Base64_string_to_Uint8Array_or_ArrayBuffer">From a Base64 string</a></li>
- <li><a href="/en-US/docs/Web/API/FileReader#readAsArrayBuffer()">From a local file</a></li>
-</ul>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<dl>
- <dt><code>ArrayBuffer.length</code></dt>
- <dd>Propriedade length do construtor de  <code>ArrayBuffer </code>cujo valor é 1.</dd>
- <dt>{{jsxref("ArrayBuffer.@@species", "get ArrayBuffer[@@species]")}}</dt>
- <dd>A função do contrutor que é usado para criar objetos derivados.</dd>
- <dt>{{jsxref("ArrayBuffer.prototype")}}</dt>
- <dd>Permite adicionar novas propriedades a todos os objetos do tipo <code>ArrayBuffer.</code></dd>
-</dl>
-
-<h2 id="Métodos">Métodos</h2>
-
-<dl>
- <dt>{{jsxref("ArrayBuffer.isView", "ArrayBuffer.isView(arg)")}}</dt>
- <dd>Devolve <code>true </code>caso <code>arg </code>é  um tipo de representação do ArrayBuffer, como <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray">typed array objects</a> ou {{jsxref("DataView")}}. Devolve <code>false </code>caso contrário</dd>
- <dt>{{jsxref("ArrayBuffer.transfer", "ArrayBuffer.transfer(oldBuffer [, newByteLength])")}} {{experimental_inline}}</dt>
- <dd>Devolve um novo objeto <code>ArrayBuffer </code>cujo conteúdo é obtido do <code>oldBuffer </code>e ou é truncado ou preenchido a zeros pelo <code> newByteLength.</code></dd>
-</dl>
-
-<h2 id="Instâncias_ArrayBuffer">Instâncias ArrayBuffer</h2>
-
-<p>Todas as instâncias de <code>ArrayBuffer</code> herdam de {{jsxref("ArrayBuffer.prototype")}}.</p>
-
-<h3 id="Propriedades_2">Propriedades</h3>
-
-<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Properties')}}</p>
-
-<h3 id="Métodos_2">Métodos</h3>
-
-<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/ArrayBuffer/prototype','Methods')}}</p>
-
-<dl>
- <dt>{{jsxref("ArrayBuffer.slice()")}} {{non-standard_inline}}</dt>
- <dd>Tem a mesma funcionalidade que {{jsxref("ArrayBuffer.prototype.slice()")}}.</dd>
-</dl>
-
-<h2 id="Exemplo">Exemplo</h2>
-
-<p>Neste exemplo, criamos um buffer de 8 bytes com representação {{jsxref("Global_Objects/Int32Array", "Int32Array")}} a referênciar o buffer:</p>
-
-<pre class="brush: js">var buffer = new ArrayBuffer(8);
-var view   = new Int32Array(buffer);</pre>
-
-<h2 id="Especificação">Especificação</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('Typed Array')}}</td>
-   <td>{{Spec2('Typed Array')}}</td>
-   <td>Substituido por ECMAScript 6.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>
-    <p>Definição inicial no stardard da ECMA. Especificar que <code>new </code>era necessário.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arraybuffer-constructor', 'ArrayBuffer')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_nos_navegadores">Compatibilidade nos navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>7.0</td>
-   <td>{{CompatGeckoDesktop("2")}}</td>
-   <td>10</td>
-   <td>11.6</td>
-   <td>5.1</td>
-  </tr>
-  <tr>
-   <td><code>ArrayBuffer()</code> without <code>new</code> throws</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoDesktop("44")}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td><code>ArrayBuffer.slice()</code> {{non-standard_inline}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatVersionUnknown}}<br>
-    {{CompatNo}} {{CompatGeckoDesktop("53")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>4.0</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoMobile("2")}}</td>
-   <td>10</td>
-   <td>11.6</td>
-   <td>4.2</td>
-  </tr>
-  <tr>
-   <td><code>ArrayBuffer()</code> without <code>new</code> throws</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile("44")}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td><code>ArrayBuffer.slice()</code> {{non-standard_inline}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatVersionUnknown}}<br>
-    {{CompatNo}} {{CompatGeckoMobile("53")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Notas_de_compatibilidade">Notas de compatibilidade</h2>
-
-<p>Com ECMAScript 2015, construtores de <code>ArrayBuffer </code>são obrigados a usar o operador<code> </code>{{jsxref("Operators/new", "new")}}. Daqui adiante ao invocar <code>ArrayBuffer </code>como uma função sem<code> new </code>irá lançar uma exceção {{jsxref("TypeError")}}.</p>
-
-<pre class="brush: js example-bad">var dv = ArrayBuffer(10);
-// TypeError: calling a builtin ArrayBuffer constructor
-// without new is forbidden</pre>
-
-<pre class="brush: js example-good">var dv = new ArrayBuffer(10);</pre>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li><a href="/en-US/docs/Web/JavaScript/Typed_arrays">JavaScript typed arrays</a></li>
- <li>{{jsxref("SharedArrayBuffer")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/asyncfunction/index.html b/files/pt-pt/web/javascript/reference/global_objects/asyncfunction/index.html
deleted file mode 100644
index 4e454bacd9..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/asyncfunction/index.html
+++ /dev/null
@@ -1,124 +0,0 @@
----
-title: AsyncFunction
-slug: Web/JavaScript/Reference/Global_Objects/AsyncFunction
-translation_of: Web/JavaScript/Reference/Global_Objects/AsyncFunction
----
-<div>{{JSRef}}</div>
-
-<div>O constructor da função <strong>Async</strong> cria um novo objecto {{jsxref("Statements/async_function", "async function")}}. Em Javascript todas as funções asíncronas são na verdade objectos <code>AsyncFunction.</code></div>
-
-<p> </p>
-
-<p>Note-se que <code>AsyncFunction</code> não é um objecto global. Pode ser obtido da seguinte forma.</p>
-
-<pre class="brush: js">Object.getPrototypeOf(async function(){}).constructor
-</pre>
-
-<h2 id="Síntaxe">Síntaxe</h2>
-
-<pre class="syntaxbox">new AsyncFunction([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
- <dd>Nomes usados pela função como nomes formais de argumentos . Cada um dos argumentos tem que ser uma <em>string</em> que corresponde a um identificador válido JavaScript ou uma lista separada por vírgulas; por exemplo "<code>x</code>", "<code>theValue</code>", ou "<code>a,b</code>".</dd>
- <dt><code>functionBody</code></dt>
- <dd>Uma <em>string</em> com os termos JavaScript que fazem parte da definição da função.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Os objectos {{jsxref("Statements/async_function", "async function")}} criados com o <em>constructor</em> <code>AsyncFunction</code> passam por um <em>parsing</em> quando as funções são criadas. Isto é menos eficiente que declarar uma função asíncrona com {{jsxref("Statements/async_function", "async function expression")}} e chamá-la no código porque dessa forma a função passa pelo <em>parsing</em> ao mesmo tempo que o resto do código.</p>
-
-<p>Todos os argumentos passados à função são tratados como os nomes dos identificadores dos parâmetros na função a ser criada, na ordem que são declarados.</p>
-
-<div class="note">
-<p><strong>Nota:</strong> {{jsxref("Statements/async_function", "async functions")}} criado com o <em>constructor</em> <code>AsyncFunction</code> não estão encapsulados ao contexto da sua criação, são sempre criados no âmbito global.</p>
-
-<p>Ao correr, podem aceder às suas prórpias variáveis e às variáveis globais, no entanto não conseguem aceder às que estão no contexto donde o constructor <code>AsyncFunction</code> foi chamado. Isto é diferente de chamar {{jsxref("Global_Objects/eval", "eval")}} com código para uma função asíncrona.</p>
-</div>
-
-<p>A invocação do constructor <code>AsyncFunction</code> como uma função, i.e. sem usar o operador <code>new</code> tem o mesmo efeito que invocá-lo como <em>constructor</em>.</p>
-
-<p>Invoking the <code>AsyncFunction</code> constructor as a function (without using the <code>new</code> operator) has the same effect as invoking it as a constructor.</p>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<dl>
- <dt><code><strong>AsyncFunction.length</strong></code></dt>
- <dd>A propriedade comprimento do <em>constructor</em> do <code>AsyncFunction</code>, cujo valor é 1.</dd>
- <dt>{{jsxref("AsyncFunction.prototype")}}</dt>
- <dd>Permite adicionar propriedades a todos os objectos que são funções asíncronas.</dd>
-</dl>
-
-<h2 id="AsyncFunction_prototype_object"><code>AsyncFunction</code> prototype object</h2>
-
-<h3 id="Propriedades_2">Propriedades</h3>
-
-<div>{{page('/pt-PT/docs/Web/JavaScript/Reference/Global_Objects/AsyncFunction/prototype', 'Properties')}}</div>
-
-<h2 id="Instâncias_de_AsyncFunction">Instâncias de <code>AsyncFunction</code></h2>
-
-<p>As instâncias de <code>AsyncFunction</code> herdam métodos e propriedades do {{jsxref("AsyncFunction.prototype")}}. Tal como com qualquer <em>constructor</em> pode-se mudar o <em>prototype object</em> para aplicar mudanças a todos as instâncias de <code>AsyncFunction</code>.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Exemplo_de_criação_de_uma_função_async_a_partir_de_um_constructor_AsyncFunction">Exemplo de criação de uma função <em>async</em> a partir de um <em>constructor</em> <code>AsyncFunction</code></h3>
-
-<pre class="brush: js">function resolveAfter2Seconds(x) {
-  return new Promise(resolve =&gt; {
-    setTimeout(() =&gt; {
-      resolve(x);
-    }, 2000);
-  });
-}
-
-var AsyncFunction = Object.getPrototypeOf(async function(){}).constructor
-
-var a = new AsyncFunction('a',
-                          'b',
-                          'return await resolveAfter2Seconds(a) + await resolveAfter2Seconds(b);');
-
-a(10, 20).then(v =&gt; {
-  console.log(v); // prints 30 after 4 seconds
-});
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-async-function-objects', 'AsyncFunction object')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Definição inicial em ES2017.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.AsyncFunction")}}</p>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("Statements/async_function", "async function function")}}</li>
- <li>{{jsxref("Operators/async_function", "async function expression")}}</li>
- <li>{{jsxref("Global_Objects/Function", "Function")}}</li>
- <li>{{jsxref("Statements/function", "function statement")}}</li>
- <li>{{jsxref("Operators/function", "function expression")}}</li>
- <li>{{jsxref("Functions_and_function_scope", "Functions and function scope", "", 1)}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/boolean/index.html b/files/pt-pt/web/javascript/reference/global_objects/boolean/index.html
deleted file mode 100644
index e8482a2c0e..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/boolean/index.html
+++ /dev/null
@@ -1,156 +0,0 @@
----
-title: Booliano
-slug: Web/JavaScript/Reference/Global_Objects/Boolean
-tags:
-  - Boolean
-  - Booliano
-  - Constructor
-  - JavaScript
-translation_of: Web/JavaScript/Reference/Global_Objects/Boolean
----
-<div>{{JSRef}}</div>
-
-<p>O objeto <strong><code>Boolean</code></strong> é um <em>wrapper</em> objeto para um valor booliano.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox">new Boolean([<var>value</var>])</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><em><code>value</code></em></dt>
- <dd>Opcional. O valor incial do objeto <em><code>Boolean</code></em>.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>The value passed as the first parameter is converted to a boolean value, if necessary. If the value is omitted or is <code>0</code>, <code>-0</code>, {{jsxref("null")}}, <code>false</code>, {{jsxref("NaN")}}, {{jsxref("undefined")}}, or the empty string (<code>""</code>), the object has an initial value of <code>false</code>. If the DOM object {{domxref("document.all")}} is passed as a parameter, the new boolean object also has an initial value of <code>false</code>. All other values, including any object or the string <code>"false"</code>, create an object with an initial value of <code>true</code>.</p>
-
-<p>Do not confuse the primitive <code>Boolean</code> values <code>true</code> and <code>false</code> with the <code>true</code> and <code>false</code> values of the <code>Boolean</code> object.</p>
-
-<p>Any object of which the value is not {{jsxref("undefined")}} or {{jsxref("null")}}, including a <code>Boolean</code> object whose value is <code>false</code>, evaluates to <code>true</code> when passed to a conditional statement. For example, the condition in the following {{jsxref("Statements/if...else", "if")}} statement evaluates to <code>true</code>:</p>
-
-<pre class="brush: js">var x = new Boolean(false);
-if (x) {
-  // this code is executed
-}
-</pre>
-
-<p>This behavior does not apply to <code>Boolean</code> primitives. For example, the condition in the following {{jsxref("Statements/if...else", "if")}} statement evaluates to <code>false</code>:</p>
-
-<pre class="brush: js">var x = false;
-if (x) {
-  // this code is not executed
-}
-</pre>
-
-<p>Do not use a <code>Boolean</code> object to convert a non-boolean value to a boolean value. Instead, use <code>Boolean</code> as a function to perform this task:</p>
-
-<pre class="brush: js">var x = Boolean(expression);     // preferred
-var x = new Boolean(expression); // don't use
-</pre>
-
-<p>If you specify any object, including a <code>Boolean</code> object whose value is <code>false</code>, as the initial value of a <code>Boolean</code> object, the new <code>Boolean</code> object has a value of <code>true</code>.</p>
-
-<pre class="brush: js">var myFalse = Boolean(false);   // initial value of false
-var g = Boolean(myFalse);       // initial value of true
-var myString = new String('Hello'); // string object
-var s = Boolean(myString);      // initial value of true
-</pre>
-
-<p>Do not use a <code>Boolean</code> object in place of a <code>Boolean</code> primitive.</p>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<dl>
- <dt><code>Boolean.length</code></dt>
- <dd>Length property whose value is 1.</dd>
- <dt>{{jsxref("Boolean.prototype")}}</dt>
- <dd>Represents the prototype for the <code>Boolean</code> constructor.</dd>
-</dl>
-
-<h2 id="Métodos">Métodos</h2>
-
-<p>While the global <code>Boolean</code> object contains no methods of its own, it does inherit some methods through the prototype chain:</p>
-
-<h2 id="Instâncias_Boolean">Instâncias <em><code>Boolean</code></em></h2>
-
-<p>All <code>Boolean</code> instances inherit from {{jsxref("Boolean.prototype")}}. As with all constructors, the prototype object dictates instances' inherited properties and methods.</p>
-
-<h3 id="Propridades">Propridades</h3>
-
-<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Properties')}}</div>
-
-<h3 id="Métodos_2">Métodos</h3>
-
-<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Boolean/prototype', 'Methods')}}</div>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Criar_objetos_Boolean_com_um_valor_inicial_de_false">Criar objetos <em><code>Boolean</code> </em>com um valor inicial de <em><code>false</code></em></h3>
-
-<pre class="brush: js">var bNoParam = Boolean();
-var bZero = Boolean(0);
-var bNull = Boolean(null);
-var bEmptyString = Boolean('');
-var bfalse = Boolean(false);
-</pre>
-
-<h3 id="Criar_objetos_Boolean_com_um_valor_inicial_de_verdadeiro">Criar objetos <em><code>Boolean</code> </em>com um valor inicial de <em><code>verdadeiro</code></em></h3>
-
-<pre class="brush: js">var btrue = Boolean(true);
-var btrueString = Boolean('true');
-var bfalseString = Boolean('false');
-var bSuLin = Boolean('Su Lin');
-var bArrayProto = Boolean([]);
-var bObjProto = Boolean({});
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.6', 'Boolean')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-boolean-objects', 'Boolean')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-boolean-objects', 'Boolean')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Boolean")}}</p>
-</div>
-
-<h2 id="Consulte_também">Consulte também</h2>
-
-<ul>
- <li>{{jsxref("Boolean.prototype")}}</li>
- <li>{{Glossary("Booliano")}}</li>
- <li><a href="https://pt.wikipedia.org/wiki/Booleano">Tipo de dados Booliano (Wikipedia)</a></li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/encodeuri/index.html b/files/pt-pt/web/javascript/reference/global_objects/encodeuri/index.html
deleted file mode 100644
index 5f8c84ca8e..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/encodeuri/index.html
+++ /dev/null
@@ -1,152 +0,0 @@
----
-title: encodeURI()
-slug: Web/JavaScript/Reference/Global_Objects/encodeURI
-translation_of: Web/JavaScript/Reference/Global_Objects/encodeURI
----
-<div>{{jsSidebar("Objects")}}</div>
-
-<p>O método <code><strong>encodeURI()</strong></code> codifica um Uniform Resource Identifier (URI) substituindo cada instancia de determinados caracteres por um, dois, três, ou quatro sequências de escape que representem a codificação UTF-8 do caracter (apenas serão quatro sequências de caracteres de escape para caracteres compostos por dois caracteres de "substituição").</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code>encodeURI(<em>URI</em>)</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>URI</code></dt>
- <dd>Um Uniform Resource Identifier completo.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Assumindo que o URI é um URI completo, não serão codificados caracteres reservados que tenham significado especial no URI.</p>
-
-<p><code>encodeURI</code> substitui todos os caracteres <strong>excepto</strong> as seguintes sequências de escape UTF-8:</p>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <td class="header">Tipo</td>
-   <td class="header">Incluído</td>
-  </tr>
-  <tr>
-   <td>Caracteres reservados</td>
-   <td><code>;</code> <code>,</code> <code>/</code> <code>?</code> <code>:</code> <code>@</code> <code>&amp;</code> <code>=</code> <code>+</code> <code>$</code></td>
-  </tr>
-  <tr>
-   <td>Caracteres excluídos</td>
-   <td>alfabéticos, dígitos decimais , <code>-</code> <code>_</code> <code>.</code> <code>!</code> <code>~</code> <code>*</code> <code>'</code> <code>(</code> <code>)</code></td>
-  </tr>
-  <tr>
-   <td>Ponto</td>
-   <td><code>#</code></td>
-  </tr>
- </tbody>
-</table>
-
-<p>Note-se que o método <code>encodeURI</code> <em>não consegue</em> criar correctamente os pedidos HTTP GET e POST, o mesmo aplica-se para XMLHTTPRequests, porque os caracteres "&amp;", "+", e "=" não são codificados, por se tratarem de caracteres especiais nos pedidos GET e POST. {{jsxref("encodeURIComponent")}}, no entanto, codifica estes caracteres.</p>
-
-<p>Note-se que será lançado um {{jsxref("URIError")}} caso se tente codificar um substituto que não faça parte de um par superior-inferior, p.ex.,</p>
-
-<pre class="brush: js">// par superior-inferior ok
-console.log(encodeURI('\uD800\uDFFF'));
-
-// substituição única de par superior lança "URIError: malformed URI sequence"
-console.log(encodeURI('\uD800'));
-
-// substituição única de par inferior lança "URIError: malformed URI sequence"
-console.log(encodeURI('\uDFFF')); </pre>
-
-<p>Note-se também que caso se pretenda seguir a mais recente norma para URLs <a href="http://tools.ietf.org/html/rfc3986">RFC3986</a>, que torna os parênteses rectos reservados (para IPv6) e, por consequência, não será codificado quando fizer parte de um URL (como um host), o seguinte exemplo de código pode ajudar:</p>
-
-<pre class="brush: js">function fixedEncodeURI (str) {
-    return encodeURI(str).replace(/%5B/g, '[').replace(/%5D/g, ']');
-}</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.1.3.3', 'encodeURI')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-encodeuri-uri', 'encodeURI')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_navegador">Compatibilidade com navegador</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("decodeURI")}}</li>
- <li>{{jsxref("encodeURIComponent")}}</li>
- <li>{{jsxref("decodeURIComponent")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/function/arguments/index.html b/files/pt-pt/web/javascript/reference/global_objects/function/arguments/index.html
deleted file mode 100644
index 4c9bf9e96e..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/function/arguments/index.html
+++ /dev/null
@@ -1,88 +0,0 @@
----
-title: Function.arguments
-slug: Web/JavaScript/Reference/Global_Objects/Function/arguments
-translation_of: Web/JavaScript/Reference/Global_Objects/Function/arguments
----
-<div>{{JSRef}} {{deprecated_header}}</div>
-
-<div>A propriedade <strong><code><em>function.arguments</em></code></strong> refere-se a um objecto com aspecto de <em>array</em> que corresponde aos argumentos da função. Ao invés disso, use a variável {{jsxref("Functions/arguments", "arguments")}}. Esta propriedade é proibida no modo <em>strict</em> devido ao <em><a href="http://www.ecma-international.org/ecma-262/6.0/#sec-addrestrictedfunctionproperties">tail call optimization</a></em>.</div>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>A síntaxe <code>function.arguments</code> está obsoleta. A forma recomendade de aceder ao objecto {{jsxref("Functions/arguments", "arguments")}} disponível nas função é usar simplesment a variável {{jsxref("Functions/arguments", "arguments")}}.</p>
-
-<p>No caso de recursão isto é, se uma funão <code>f</code> aparece várias vezes na <em>stack, </em>o valor de <code>f.arguments</code> representa os argumentos correspondentes à mais recente chamada da função.</p>
-
-<p>O valor da propriedade <code>arguments</code> é tipicamente <em>null</em> se não há nenuma invocação da função a acontecer, ou seja, a função foi chamada mas ainda não retornou.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<pre class="brush: js">function f(n) { g(n - 1); }
-
-function g(n) {
-  console.log('antes: ' + g.arguments[0]);
-  if (n &gt; 0) { f(n); }
-  console.log('depois: ' + g.arguments[0]);
-}
-
-f(2);
-
-console.log('retornado: ' + g.arguments);
-
-// Output
-
-// antes: 1
-// antes: 0
-// depois: 0
-// depois: 1
-// retornado: null
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>
-    <p>Definição inicial. Implementado em JavaScript 1.0. Tornado obsoleto a favor de {{jsxref("Functions/arguments", "arguments")}} em ES3.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-10.6', 'arguments object')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Objecto {{jsxref("Functions/arguments", "arguments")}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-arguments-object', 'arguments object')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Objecto {{jsxref("Functions/arguments", "arguments")}}</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-arguments-object', 'arguments object')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Objecto {{jsxref("Functions/arguments", "arguments")}}</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_navegadores">Compatibilidade navegadores</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Function.arguments")}}</p>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>Objecto {{jsxref("Functions/arguments", "arguments")}}</li>
- <li>{{jsxref("Functions", "Functions and function scope", "", 1)}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/function/call/index.html b/files/pt-pt/web/javascript/reference/global_objects/function/call/index.html
deleted file mode 100644
index fa3faee130..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/function/call/index.html
+++ /dev/null
@@ -1,164 +0,0 @@
----
-title: Function.prototype.call()
-slug: Web/JavaScript/Reference/Global_Objects/Function/call
-tags:
-  - Function
-  - JavaScript
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Function/call
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>call()</strong></code> realiza a chamada de uma função com o parâmetros <code>this</code> além de outros parâmetros fornecidos individualmente.</p>
-
-<div>{{EmbedInteractiveExample("pages/js/function-call.html")}}</div>
-
-
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox notranslate"><var>func</var>.call([<var>thisArg</var>[, <var>arg1</var>, <var>arg2</var>, ...<var>argN</var>]])</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><em><code>thisArg</code></em> {{optional_inline}}</dt>
- <dd>O valor de <code>this</code> fornecido ao chamar <code><em>func</em></code>.</dd>
-</dl>
-
-<div class="blockIndicator note">
-<p>Aviso: Em certos casos, <em><code>thisArg</code></em> pode não ser o valor que o método vê.</p>
-
-<p>Se o método for uma função em {{jsxref("Strict_mode", "non-strict mode", "", 1)}}, {{jsxref("Global_Objects/null", "null")}} e {{jsxref("Global_Objects/undefined", "undefined")}} são substituídos pelo objeto global, e valores primitivos são convertidos em objetos.</p>
-</div>
-
-<dl>
- <dt><em><code>arg1, arg2, ...argN</code></em> {{optional_inline}}</dt>
- <dd>Parâmetros para a função.</dd>
-</dl>
-
-<h3 id="Resultado">Resultado</h3>
-
-<p>O resultado ao chamar a função em questão com os parâmetros <code>this</code> e os outros argumentos especificados.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p><code>call()</code> permite uma função / método pertencendo a um objeto, ser atribuída a outro objeto e ser chamada desse mesmo.</p>
-
-<p><code>call()</code> fornece um novo valor para <code>this</code> à função / método. Com <code>call()</code>, pode escrever um método uma vez, e depois herdar o método noutro objeto, sem ter de rescrever a função para o novo objeto.</p>
-
-<div class="blockIndicator note">
-<p>Nota: Apesar de a sintaxe da função ser quase idêntica à da {{jsxref("Function.prototype.apply", "apply()")}}, a principal diferença é que <code>call()</code> aceita uma <strong>lista de argumentos</strong> (<code>arg1, arg2, ...argN</code>), enquanto <code>apply()</code> aceita <strong>uma matriz de argumentos</strong> (<code>[arg1, arg2, ...argN]</code>).</p>
-</div>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usar_call_para_encadear_construtores_dum_objeto">Usar <code>call</code> para encadear construtores dum objeto</h3>
-
-<p>É possível utilizar <code>call</code> para encadear construtores para um objeto (como em Java).</p>
-
-<p>No exemplo abaixo, o construtor para o objeto <code>Product</code> é definido com dois parâmetros: <code>name</code> e <code>price</code>.</p>
-
-<p>Duas outras funções, <code>Food</code> e <code>Toy</code>, invocam <code>Product</code> passando os parâmetros <code>this</code><font face="Open Sans, arial, sans-serif">, </font><code>name</code> e <code>price</code>. As funções <code>Food</code> e <code>Toy</code> também definem a propriadade <code>category</code>.</p>
-
-<pre class="brush: js notranslate">function Product(name, price) {
-  this.name = name;
-  this.price = price;
-}
-
-function Food(name, price) {
-  Product.call(this, name, price);
-  this.category = 'food';
-}
-
-function Toy(name, price) {
-  Product.call(this, name, price);
-  this.category = 'toy';
-}
-
-const cheese = new Food('feta', 5);
-const fun = new Toy('robot', 40);</pre>
-
-<h3 id="Usar_call_para_invocar_uma_função_anónima">Usar <code>call</code> para invocar uma função anónima</h3>
-
-<p>Neste exemplo, criamos uma função anónima e utilizamos <code>call</code> para invocá-la em cada objeto na matriz.</p>
-
-<p>O principal objetivo da função anónima é inserir a função <code>print</code> em cada objeto. A função <code>print</code> imprimir o índice do objeto na matriz em que se encontra.</p>
-
-<div class="blockIndicator note">
-<p>Passar o objeto desta forma (como <code>this</code>) não é necessário, mas foi feito de forma a exemplificar a função.</p>
-</div>
-
-<pre class="brush: js notranslate">var animals = [
-  { species: 'Lion', name: 'King' },
-  { species: 'Whale', name: 'Fail' }
-];
-
-for (var i = 0; i &lt; animals.length; i++) {
-  (function(i) {
-    this.print = function() {
-      console.log('#' + i + ' ' + this.species
-                  + ': ' + this.name);
-    }
-    this.print();
-  }).call(animals[i], i);
-}
-</pre>
-
-<h3 id="Usar_call_para_invocar_a_função_sem_especificar_o_primeiro_argumento">Usar <code>call</code> para invocar a função sem especificar o primeiro argumento</h3>
-
-<p>No exemplo abaixo, quando chamamos a função <code>display</code> sem passar o primeiro argumento. Se o primeiro argumento não é especificado, o objeto global é atribuído a <code>this</code>.<br>
-  </p>
-
-<pre class="brush: js notranslate">var sData = 'Wisen';
-
-function display() {
-  console.log('sData value is %s ', this.sData);
-}
-
-display.call();  // sData value is Wisen</pre>
-
-<div class="note">
-<p><strong>Aviso:</strong> Em "strict mode", o valor de <code>this</code> é <code>undefined</code>, exemplificado em baixo.</p>
-</div>
-
-<pre class="brush: js notranslate">'use strict';
-
-var sData = 'Wisen';
-
-function display() {
-  console.log('sData value is %s ', this.sData);
-}
-
-display.call(); // Cannot read the property of 'sData' of undefined</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Especificação</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function.prototype.call', 'Function.prototype.call')}}</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-
-
-<p>{{Compat("javascript.builtins.Function.call")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Function.prototype.bind()")}}</li>
- <li>{{jsxref("Function.prototype.apply()")}}</li>
- <li>
-  <p><a href="/en-US/docs/Web/JavaScript/Introduction_to_Object-Oriented_JavaScript">Introduction to Object-Oriented JavaScript</a></p>
- </li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/function/index.html b/files/pt-pt/web/javascript/reference/global_objects/function/index.html
deleted file mode 100644
index 6ebfd66c44..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/function/index.html
+++ /dev/null
@@ -1,192 +0,0 @@
----
-title: Function
-slug: Web/JavaScript/Reference/Global_Objects/Function
-tags:
-  - Constructor
-  - Function
-  - JavaScript
-  - NeedsTranslation
-  - TopicStub
-translation_of: Web/JavaScript/Reference/Global_Objects/Function
----
-<div>{{JSRef}}</div>
-
-<p>The <strong><code>Function</code> constructor</strong> creates a new <code>Function</code> object. In JavaScript every function is actually a <code>Function</code> object.</p>
-
-<h2 id="Syntax">Syntax</h2>
-
-<pre class="syntaxbox"><code>new Function ([<var>arg1</var>[, <var>arg2</var>[, ...<var>argN</var>]],] <var>functionBody</var>)</code></pre>
-
-<h3 id="Parameters">Parameters</h3>
-
-<dl>
- <dt><code>arg1, arg2, ... arg<em>N</em></code></dt>
- <dd>Names to be used by the function as formal argument names. Each must be a string that corresponds to a valid JavaScript identifier or a list of such strings separated with a comma; for example "<code>x</code>", "<code>theValue</code>", or "<code>a,b</code>".</dd>
- <dt><code>functionBody</code></dt>
- <dd>A string containing the JavaScript statements comprising the function definition.</dd>
-</dl>
-
-<h2 id="Description">Description</h2>
-
-<p><code>Function</code> objects created with the <code>Function</code> constructor are parsed when the function is created. This is less efficient than declaring a function with a <a href="/en-US/docs/Web/JavaScript/Reference/Operators/function">function expression</a> or <a href="/en-US/docs/Web/JavaScript/Reference/Statements/function">function statement</a> and calling it within your code, because such functions are parsed with the rest of the code.</p>
-
-<p>All arguments passed to the function are treated as the names of the identifiers of the parameters in the function to be created, in the order in which they are passed.</p>
-
-<p>Invoking the <code>Function</code> constructor as a function (without using the <code>new</code> operator) has the same effect as invoking it as a constructor.</p>
-
-<h2 id="Properties_and_Methods_of_Function">Properties and Methods of <code>Function</code></h2>
-
-<p>The global <code>Function</code> object has no methods or properties of its own, however, since it is a function itself it does inherit some methods and properties through the prototype chain from {{jsxref("Function.prototype")}}.</p>
-
-<h2 id="Function_prototype_object"><code>Function</code> prototype object</h2>
-
-<h3 id="Properties">Properties</h3>
-
-<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Properties')}}</div>
-
-<h3 id="Methods">Methods</h3>
-
-<div>{{page('/en-US/docs/JavaScript/Reference/Global_Objects/Function/prototype', 'Methods')}}</div>
-
-<h2 id="Function_instances"><code>Function</code> instances</h2>
-
-<p><code>Function</code> instances inherit methods and properties from {{jsxref("Function.prototype")}}. As with all constructors, you can change the constructor's prototype object to make changes to all <code>Function</code> instances.</p>
-
-<h2 id="Examples">Examples</h2>
-
-<h3 id="Specifying_arguments_with_the_Function_constructor">Specifying arguments with the <code>Function</code> constructor</h3>
-
-<p>The following code creates a <code>Function</code> object that takes two arguments.</p>
-
-<pre class="brush: js">// Example can be run directly in your JavaScript console
-
-// Create a function that takes two arguments and returns the sum of those arguments
-var adder = new Function('a', 'b', 'return a + b');
-
-// Call the function
-adder(2, 6);
-// &gt; 8
-</pre>
-
-<p>The arguments "<code>a</code>" and "<code>b</code>" are formal argument names that are used in the function body, "<code>return a + b</code>".</p>
-
-<h3 id="Difference_between_Function_constructor_and_function_declaration">Difference between Function constructor and function declaration</h3>
-
-<p>Functions created with the <code>Function</code> constructor do not create closures to their creation contexts; they always are created in the global scope. When running them, they will only be able to access their own local variables and global ones, not the ones from the scope in which the <code>Function</code> constructor was called. This is different from using {{jsxref("eval")}} with code for a function expression.</p>
-
-<pre class="brush: js">var x = 10;
-
-function createFunction1() {
-    var x = 20;
-    return new Function('return x;'); // this |x| refers global |x|
-}
-
-function createFunction2() {
-    var x = 20;
-    function f() {
-        return x; // this |x| refers local |x| above
-    }
-    return f;
-}
-
-var f1 = createFunction1();
-console.log(f1());          // 10
-var f2 = createFunction2();
-console.log(f2());          // 20
-</pre>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.3', 'Function')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-function-objects', 'Function')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-function-objects', 'Function')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("Functions", "Functions and function scope")}}</li>
- <li>{{jsxref("Function")}}</li>
- <li>{{jsxref("Statements/function", "function statement")}}</li>
- <li>{{jsxref("Operators/function", "function expression")}}</li>
- <li>{{jsxref("Statements/function*", "function* statement")}}</li>
- <li>{{jsxref("Operators/function*", "function* expression")}}</li>
- <li>{{jsxref("GeneratorFunction")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/index.html b/files/pt-pt/web/javascript/reference/global_objects/index.html
deleted file mode 100644
index f3850bdfd2..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/index.html
+++ /dev/null
@@ -1,173 +0,0 @@
----
-title: Objetos integrados padrão
-slug: Web/JavaScript/Reference/Global_Objects
-tags:
-  - Built-in
-  - JavaScript
-  - Objects
-  - Reference
-translation_of: Web/JavaScript/Reference/Global_Objects
----
-<div>{{jsSidebar("Objects")}}</div>
-
-<h2 id="Summary" name="Summary">Resumo</h2>
-
-<p>Este capítulo documenta todos os objectos built-in do JavaScript standard, juntamente com os seus métodos e propriedades.</p>
-
-<div class="onlyinclude">
-<p>O termo "objectos globais" (ou objectos built-in standard) não é para ser confundido com <em>objecto global</em>. Aqui, os objectos globais referem-se a objectos no scope global (mas apenas se o modo strict do ECMAScript 5 não estiver a ser usado! Senão retorna <code>undefined</code>). O próprio <em>global object</em> pode ser acedido através do operador {{jsxref("Operators/this", "this")}} no scope global. Na verdade, o scope global consiste nas propriedades do objecto global (incluíndo propriedades herdadas, se alguma).</p>
-
-<p>Outros objectos no scope global são <a href="/en-US/docs/Web/JavaScript/Guide/Working_with_Objects#Creating_new_objects">criados através do script do utilizador</a> or fornecidos pela aplicação host. Os objectos do host disponíveis no contexto browser são documentados na <a href="/en-US/docs/Web/API/Reference">referência da API</a>. Para mais informações sobre a distinção entre <a href="/en-US/docs/DOM/DOM_Reference">DOM</a> e o núcleo do <a href="/en-US/docs/Web/JavaScript">JavaScript</a>, ver <a href="/en-US/docs/Web/JavaScript/JavaScript_technologies_overview">exposição das tecnologias do JavaScript</a>.</p>
-
-<h2 id="Objetos_padrão_(por_categoria)">Objetos padrão (por categoria)</h2>
-
-<h3 id="Propriedades_do_valor">Propriedades do valor</h3>
-
-<p>Estas propriedades globais devolvem um valor simples; estas não têm propriedades ou métodos.</p>
-
-<ul>
- <li>{{jsxref("Infinity")}}</li>
- <li>{{jsxref("NaN")}}</li>
- <li>{{jsxref("undefined")}}</li>
- <li>{{jsxref("null")}} literal</li>
-</ul>
-
-<h3 id="Propriedades_da_função">Propriedades da função</h3>
-
-<p>Estas funções globais - funções que são chamadas no mundo ao invés de um objeto - devolvem diretamente os seus resultados para o chamador.</p>
-
-<ul>
- <li>{{jsxref("Global_Objects/eval", "eval()")}}</li>
- <li>{{jsxref("Global_Objects/uneval", "uneval()")}} {{non-standard_inline()}}</li>
- <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li>
- <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li>
- <li>{{jsxref("Global_Objects/parseFloat", "parseFloat()")}}</li>
- <li>{{jsxref("Global_Objects/parseInt", "parseInt()")}}</li>
- <li>{{jsxref("Global_Objects/decodeURI", "decodeURI()")}}</li>
- <li>{{jsxref("Global_Objects/decodeURIComponent", "decodeURIComponent()")}}</li>
- <li>{{jsxref("Global_Objects/encodeURI", "encodeURI()")}}</li>
- <li>{{jsxref("Global_Objects/encodeURIComponent", "encodeURIComponent()")}}</li>
- <li>{{jsxref("Global_Objects/escape", "escape()")}} {{deprecated_inline()}}</li>
- <li>{{jsxref("Global_Objects/unescape", "unescape()")}} {{deprecated_inline()}}</li>
-</ul>
-
-<h3 id="Objetos_fundamentais">Objetos fundamentais</h3>
-
-<p>Estes são os objetos básicos, fundamentais, em que todos os outros objetos são baseados. Isto inclui objetos que representam objetos gerais, funções, e erros.</p>
-
-<ul>
- <li>{{jsxref("Object")}}</li>
- <li>{{jsxref("Function")}}</li>
- <li>{{jsxref("Boolean")}}</li>
- <li>{{jsxref("Symbol")}} {{experimental_inline()}}</li>
- <li>{{jsxref("Error")}}</li>
- <li>{{jsxref("EvalError")}}</li>
- <li>{{jsxref("InternalError")}}</li>
- <li>{{jsxref("RangeError")}}</li>
- <li>{{jsxref("ReferenceError")}}</li>
- <li>{{jsxref("StopIteration")}}</li>
- <li>{{jsxref("SyntaxError")}}</li>
- <li>{{jsxref("TypeError")}}</li>
- <li>{{jsxref("URIError")}}</li>
-</ul>
-
-<h3 id="Números_e_datas">Números e datas</h3>
-
-<p>Objectos que lidam com números, datas e cálculos matemáticos.</p>
-
-<ul>
- <li>{{jsxref("Number")}}</li>
- <li>{{jsxref("Math")}}</li>
- <li>{{jsxref("Date")}}</li>
-</ul>
-
-<h3 id="Processamento_de_texto">Processamento de texto</h3>
-
-<p>Objectos para manipular texto.</p>
-
-<ul>
- <li>{{jsxref("String")}}</li>
- <li>{{jsxref("RegExp")}}</li>
-</ul>
-
-<h3 id="Coleções_indexadas">Coleções indexadas</h3>
-
-<p>Coleções ordenadas por um indíce. Objectos do tipo array.</p>
-
-<ul>
- <li>{{jsxref("Array")}}</li>
- <li>{{jsxref("Int8Array")}}</li>
- <li>{{jsxref("Uint8Array")}}</li>
- <li>{{jsxref("Uint8ClampedArray")}}</li>
- <li>{{jsxref("Int16Array")}}</li>
- <li>{{jsxref("Uint16Array")}}</li>
- <li>{{jsxref("Int32Array")}}</li>
- <li>{{jsxref("Uint32Array")}}</li>
- <li>{{jsxref("Float32Array")}}</li>
- <li>{{jsxref("Float64Array")}}</li>
- <li>{{jsxref("ParallelArray")}} {{non-standard_inline()}}</li>
-</ul>
-
-<h3 id="Coleções_por_chave">Coleções por chave</h3>
-
-<p>Coleções de objectos como chaves. Elementos iteráveis por ordem de inserção.</p>
-
-<ul>
- <li>{{jsxref("Map")}} {{experimental_inline()}}</li>
- <li>{{jsxref("Set")}} {{experimental_inline()}}</li>
- <li>{{jsxref("WeakMap")}} {{experimental_inline()}}</li>
- <li>{{jsxref("WeakSet")}} {{experimental_inline()}}</li>
-</ul>
-
-<h3 id="Dados_estruturados">Dados estruturados</h3>
-
-<p>Buffers de dados e <strong>J</strong>ava<strong>S</strong>cript <strong>O</strong>bject <strong>N</strong>otation (JSON).</p>
-
-<ul>
- <li>{{jsxref("ArrayBuffer")}}</li>
- <li>{{jsxref("DataView")}}</li>
- <li>{{jsxref("JSON")}}</li>
-</ul>
-
-<h3 id="Objectos_de_abstração_de_controlo">Objectos de abstração de controlo</h3>
-
-<ul>
- <li>{{jsxref("Iterator")}} {{non-standard_inline()}}</li>
- <li>{{jsxref("Generator")}} {{experimental_inline()}}</li>
- <li>{{jsxref("Promise")}} {{experimental_inline()}}</li>
-</ul>
-
-<h3 id="Reflexão">Reflexão</h3>
-
-<ul>
- <li>{{jsxref("Reflect")}} {{experimental_inline()}}</li>
- <li>{{jsxref("Proxy")}} {{experimental_inline()}}</li>
-</ul>
-
-<h3 id="Internacionalização">Internacionalização</h3>
-
-<p>Adições ao núcleo do ECMAScript para funcionalidades de linguagens sensíveis.</p>
-
-<ul>
- <li>{{jsxref("Intl")}}</li>
- <li>{{jsxref("Global_Objects/Collator", "Intl.Collator")}}</li>
- <li>{{jsxref("Global_Objects/DateTimeFormat", "Intl.DateTimeFormat")}}</li>
- <li>{{jsxref("Global_Objects/NumberFormat", "Intl.NumberFormat")}}</li>
-</ul>
-
-<h3 id="Objetos_não_padrão">Objetos não padrão</h3>
-
-<ul>
- <li>{{jsxref("Iterator")}} {{non-standard_inline}}</li>
- <li>{{jsxref("ParallelArray")}} {{non-standard_inline}}</li>
- <li>{{jsxref("StopIteration")}} {{non-standard_inline}}</li>
-</ul>
-
-<h3 id="Outros">Outros</h3>
-
-<ul>
- <li><code><a href="/en-US/docs/Web/JavaScript/Reference/Functions/arguments">Argumentos</a></code></li>
-</ul>
-</div>
-
-<p> </p>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/infinity/index.html b/files/pt-pt/web/javascript/reference/global_objects/infinity/index.html
deleted file mode 100644
index 818471e60e..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/infinity/index.html
+++ /dev/null
@@ -1,69 +0,0 @@
----
-title: Infinity
-slug: Web/JavaScript/Reference/Global_Objects/Infinity
-tags:
-  - JavaScript
-  - Propriedade
-  - Referencia
-translation_of: Web/JavaScript/Reference/Global_Objects/Infinity
----
-<div>{{jsSidebar("Objects")}}</div>
-
-<p>A propriedade global <code><strong>Infinity</strong></code> é um valor numérico que representa o infinito.</p>
-
-<p>{{js_property_attributes(0,0,0)}}</p>
-
-<div>{{EmbedInteractiveExample("pages/js/globalprops-infinity.html")}}</div>
-
-<div class="hidden">The source for this interactive example is stored in a GitHub repository. If you'd like to contribute to the interactive examples project, please clone <a href="https://github.com/mdn/interactive-examples">https://github.com/mdn/interactive-examples</a> and send us a pull request.</div>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p><code>Infinity</code> é uma propriedade do objeto <code>global</code>. Isto é para dizer que é um variável com um escopo global.</p>
-
-<p>O valor inicial do <code>Infinity</code> é {{jsxref("Number.POSITIVE_INFINITY")}}. O valor <code>Infinity</code> (infinito positivo) é maior que qualquer outro número.</p>
-
-<p>Este valor age de form diferente do infinito matematico; veja {{jsxref("Number.POSITIVE_INFINITY")}} para mais detalhes.</p>
-
-<p>Como definido na especificação ECMAScript 5, <code>Infinity</code> é <em>read-only</em> (implementado em JavaScript 1.8.5 / Firefox 4).</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usar_Infinity">Usar Infinity</h3>
-
-<pre class="brush: js notranslate">console.log(Infinity          ); /* Infinity */
-console.log(Infinity + 1      ); /* Infinity */
-console.log(Math.pow(10, 1000)); /* Infinity */
-console.log(Math.log(0)       ); /* -Infinity */
-console.log(1 / Infinity      ); /* 0 */
-console.log(1 / 0             ); /* Infinity */
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Especificação</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-value-properties-of-the-global-object-infinity', 'Infinity')}}</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade">Compatibilidade</h2>
-
-
-
-<p>{{Compat("javascript.builtins.Infinity")}}</p>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Number.NEGATIVE_INFINITY")}}</li>
- <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
- <li>{{jsxref("Number.isFinite")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/math/ceil/index.html b/files/pt-pt/web/javascript/reference/global_objects/math/ceil/index.html
deleted file mode 100644
index c89b15567a..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/math/ceil/index.html
+++ /dev/null
@@ -1,161 +0,0 @@
----
-title: Math.ceil()
-slug: Web/JavaScript/Reference/Global_Objects/Math/ceil
-translation_of: Web/JavaScript/Reference/Global_Objects/Math/ceil
----
-<div>{{JSRef}}</div>
-
-<p>A função <strong><code>Math.ceil()</code></strong> retorna um inteiro smallest (sem casas decimais) maior ou igual ao n.º passado como parâmetro. Por exemplo ao fazer Math.ceil(3.01) o valor retornado é 4, ao fazer Math.ceil(-5.01) o retorno é -5, ao fazer Math.ceil(7) o valor devolvido é 7. </p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code>Math.ceil(<var>x</var>)</code></pre>
-
-<h3 id="Parametros">Parametros</h3>
-
-<dl>
- <dt><code>x</code></dt>
- <dd>Um número.</dd>
-</dl>
-
-<h3 id="Valor_de_retorno">Valor de retorno</h3>
-
-<p>Um inteiro smallest maior ou igual ao n.º passado como parâmetro.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Como <code>ceil()</code> é um método estático de  <code>Math</code>,  pode sempre ser usado como <code>Math.ceil()</code>, o objeto <code>Math</code> não é um construtor. </p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Utilizando_Math.ceil">Utilizando <code>Math.ceil()</code></h3>
-
-<p>Seguem exemplos da utilização de <code>Math.ceil()</code>.</p>
-
-<pre class="brush: js">Math.ceil(.95);    // 1
-Math.ceil(4);      // 4
-Math.ceil(7.004);  // 8
-Math.ceil(-0.95);  // -0
-Math.ceil(-4);     // -4
-Math.ceil(-7.004); // -7
-</pre>
-
-<h3 id="Ajustamento_decimal">Ajustamento decimal </h3>
-
-<pre class="brush: js">// Closure
-(function() {
-  /**
-   * Decimal adjustment of a number.
-   *
-   * @param {String}  type  The type of adjustment.
-   * @param {Number}  value The number.
-   * @param {Integer} exp   The exponent (the 10 logarithm of the adjustment base).
-   * @returns {Number} The adjusted value.
-   */
-  function decimalAdjust(type, value, exp) {
-    // If the exp is undefined or zero...
-    if (typeof exp === 'undefined' || +exp === 0) {
-      return Math[type](value);
-    }
-    value = +value;
-    exp = +exp;
-    // If the value is not a number or the exp is not an integer...
-    if (isNaN(value) || !(typeof exp === 'number' &amp;&amp; exp % 1 === 0)) {
-      return NaN;
-    }
-    // Shift
-    value = value.toString().split('e');
-    value = Math[type](+(value[0] + 'e' + (value[1] ? (+value[1] - exp) : -exp)));
-    // Shift back
-    value = value.toString().split('e');
-    return +(value[0] + 'e' + (value[1] ? (+value[1] + exp) : exp));
-  }
-
-  // Decimal round
-  if (!Math.round10) {
-    Math.round10 = function(value, exp) {
-      return decimalAdjust('round', value, exp);
-    };
-  }
-  // Decimal floor
-  if (!Math.floor10) {
-    Math.floor10 = function(value, exp) {
-      return decimalAdjust('floor', value, exp);
-    };
-  }
-  // Decimal ceil
-  if (!Math.ceil10) {
-    Math.ceil10 = function(value, exp) {
-      return decimalAdjust('ceil', value, exp);
-    };
-  }
-})();
-
-// Round
-Math.round10(55.55, -1);   // 55.6
-Math.round10(55.549, -1);  // 55.5
-Math.round10(55, 1);       // 60
-Math.round10(54.9, 1);     // 50
-Math.round10(-55.55, -1);  // -55.5
-Math.round10(-55.551, -1); // -55.6
-Math.round10(-55, 1);      // -50
-Math.round10(-55.1, 1);    // -60
-// Floor
-Math.floor10(55.59, -1);   // 55.5
-Math.floor10(59, 1);       // 50
-Math.floor10(-55.51, -1);  // -55.6
-Math.floor10(-51, 1);      // -60
-// Ceil
-Math.ceil10(55.51, -1);    // 55.6
-Math.ceil10(51, 1);        // 60
-Math.ceil10(-55.59, -1);   // -55.5
-Math.ceil10(-59, 1);       // -50
-</pre>
-
-<h2 id="Especificações">Especificações </h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Definição inicial JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8.2.6', 'Math.ceil')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math.ceil', 'Math.ceil')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math.ceil', 'Math.ceil')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
-
-<p>{{Compat("javascript.builtins.Math.ceil")}}</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("Math.abs()")}}</li>
- <li>{{jsxref("Math.floor()")}}</li>
- <li>{{jsxref("Math.round()")}}</li>
- <li>{{jsxref("Math.sign()")}}</li>
- <li>{{jsxref("Math.trunc()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/math/index.html b/files/pt-pt/web/javascript/reference/global_objects/math/index.html
deleted file mode 100644
index 867c783782..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/math/index.html
+++ /dev/null
@@ -1,214 +0,0 @@
----
-title: Math
-slug: Web/JavaScript/Reference/Global_Objects/Math
-translation_of: Web/JavaScript/Reference/Global_Objects/Math
----
-<div>{{JSRef}}</div>
-
-<p><strong><code>Math</code></strong> é um objecto integrado que tem propriedades e métodos correspondentes a constantes e funções matemáticas. Não é um objecto função.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Contrariamente aos outros objectos globais, <code>Math</code> não é um construtor. Todas as propriedades e métodos de <code>Math</code> são estáticas. Refere-se a constante pi com <code>Math.PI</code> e chama-se a função de seno com <code>Math.sin(x)</code>, em que x é o argumento do método. As constantes estão definidas com a precisão completa dos números reais do JavaScript.</p>
-
-<p>Para extender o objecto <code>Math</code>, não se usa o protótipo. Em vez disso extende-se directamente o objecto <code>Math</code>:</p>
-
-<p>Math.nomeProp=valorProp;</p>
-
-<p>Math.nomeMetodo=refMetodo;</p>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<dl>
- <dt>{{jsxref("Math.E")}}</dt>
- <dd>Euler's constant and the base of natural logarithms, approximately 2.718.</dd>
- <dt>{{jsxref("Math.LN2")}}</dt>
- <dd>Natural logarithm of 2, approximately 0.693.</dd>
- <dt>{{jsxref("Math.LN10")}}</dt>
- <dd>Natural logarithm of 10, approximately 2.303.</dd>
- <dt>{{jsxref("Math.LOG2E")}}</dt>
- <dd>Base 2 logarithm of E, approximately 1.443.</dd>
- <dt>{{jsxref("Math.LOG10E")}}</dt>
- <dd>Base 10 logarithm of E, approximately 0.434.</dd>
- <dt>{{jsxref("Math.PI")}}</dt>
- <dd>Ratio of the circumference of a circle to its diameter, approximately 3.14159.</dd>
- <dt>{{jsxref("Math.SQRT1_2")}}</dt>
- <dd>Square root of 1/2; equivalently, 1 over the square root of 2, approximately 0.707.</dd>
- <dt>{{jsxref("Math.SQRT2")}}</dt>
- <dd>Square root of 2, approximately 1.414.</dd>
-</dl>
-
-<h2 id="Métodos">Métodos</h2>
-
-<div class="note">
-<p>Note that the trigonometric functions (<code>sin()</code>, <code>cos()</code>, <code>tan()</code>, <code>asin()</code>, <code>acos()</code>, <code>atan()</code>, <code>atan2()</code>) expect or return angles in radians. To convert radians to degrees, divide by <code>(Math.PI / 180)</code>, and multiply by this to convert the other way.</p>
-</div>
-
-<div class="note">
-<p>Note that many math functions have a precision that's implementation-dependent. This means that different browsers can give a different result, and even the same JS engine on a different OS or architecture can give different results.</p>
-</div>
-
-<dl>
- <dt>{{jsxref("Global_Objects/Math/abs", "Math.abs(x)")}}</dt>
- <dd>Returns the absolute value of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/acos", "Math.acos(x)")}}</dt>
- <dd>Returns the arccosine of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/acosh", "Math.acosh(x)")}}</dt>
- <dd>Returns the hyperbolic arccosine of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/asin", "Math.asin(x)")}}</dt>
- <dd>Returns the arcsine of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/asinh", "Math.asinh(x)")}}</dt>
- <dd>Returns the hyperbolic arcsine of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/atan", "Math.atan(x)")}}</dt>
- <dd>Returns the arctangent of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/atanh", "Math.atanh(x)")}}</dt>
- <dd>Returns the hyperbolic arctangent of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/atan2", "Math.atan2(y, x)")}}</dt>
- <dd>Returns the arctangent of the quotient of its arguments.</dd>
- <dt>{{jsxref("Global_Objects/Math/cbrt", "Math.cbrt(x)")}}</dt>
- <dd>Returns the cube root of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/ceil", "Math.ceil(x)")}}</dt>
- <dd>Returns the smallest integer greater than or equal to a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/clz32", "Math.clz32(x)")}}</dt>
- <dd>Returns the number of leading zeroes of a 32-bit integer.</dd>
- <dt>{{jsxref("Global_Objects/Math/cos", "Math.cos(x)")}}</dt>
- <dd>Returns the cosine of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/cosh", "Math.cosh(x)")}}</dt>
- <dd>Returns the hyperbolic cosine of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/exp", "Math.exp(x)")}}</dt>
- <dd>Returns E<sup>x</sup>, where <var>x</var> is the argument, and E is Euler's constant (2.718…), the base of the natural logarithm.</dd>
- <dt>{{jsxref("Global_Objects/Math/expm1", "Math.expm1(x)")}}</dt>
- <dd>Returns subtracting 1 from <code>exp(x)</code>.</dd>
- <dt>{{jsxref("Global_Objects/Math/floor", "Math.floor(x)")}}</dt>
- <dd>Returns the largest integer less than or equal to a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/fround", "Math.fround(x)")}}</dt>
- <dd>Returns the nearest <a href="http://en.wikipedia.org/wiki/Single-precision_floating-point_format" title="link to the wikipedia page on single precision">single precision</a> float representation of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/hypot", "Math.hypot([x[, y[, …]]])")}}</dt>
- <dd>Returns the square root of the sum of squares of its arguments.</dd>
- <dt>{{jsxref("Global_Objects/Math/imul", "Math.imul(x, y)")}}</dt>
- <dd>Returns the result of a 32-bit integer multiplication.</dd>
- <dt>{{jsxref("Global_Objects/Math/log", "Math.log(x)")}}</dt>
- <dd>Returns the natural logarithm (log<sub>e</sub>, also ln) of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/log1p", "Math.log1p(x)")}}</dt>
- <dd>Returns the natural logarithm (log<sub>e</sub>, also ln) of <code>1 + x</code> for a number x.</dd>
- <dt>{{jsxref("Global_Objects/Math/log10", "Math.log10(x)")}}</dt>
- <dd>Returns the base 10 logarithm of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/log2", "Math.log2(x)")}}</dt>
- <dd>Returns the base 2 logarithm of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/max", "Math.max([x[, y[, …]]])")}}</dt>
- <dd>Returns the largest of zero or more numbers.</dd>
- <dt>{{jsxref("Global_Objects/Math/min", "Math.min([x[, y[, …]]])")}}</dt>
- <dd>Returns the smallest of zero or more numbers.</dd>
- <dt>{{jsxref("Global_Objects/Math/pow", "Math.pow(x, y)")}}</dt>
- <dd>Returns base to the exponent power, that is, <code>base<sup>exponent</sup></code>.</dd>
- <dt>{{jsxref("Global_Objects/Math/random", "Math.random()")}}</dt>
- <dd>Returns a pseudo-random number between 0 and 1.</dd>
- <dt>{{jsxref("Global_Objects/Math/round", "Math.round(x)")}}</dt>
- <dd>Returns the value of a number rounded to the nearest integer.</dd>
- <dt>{{jsxref("Global_Objects/Math/sign", "Math.sign(x)")}}</dt>
- <dd>Returns the sign of the x, indicating whether x is positive, negative or zero.</dd>
- <dt>{{jsxref("Global_Objects/Math/sin", "Math.sin(x)")}}</dt>
- <dd>Returns the sine of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/sinh", "Math.sinh(x)")}}</dt>
- <dd>Returns the hyperbolic sine of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/sqrt", "Math.sqrt(x)")}}</dt>
- <dd>Returns the positive square root of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/tan", "Math.tan(x)")}}</dt>
- <dd>Returns the tangent of a number.</dd>
- <dt>{{jsxref("Global_Objects/Math/tanh", "Math.tanh(x)")}}</dt>
- <dd>Returns the hyperbolic tangent of a number.</dd>
- <dt><code>Math.toSource()</code> {{non-standard_inline}}</dt>
- <dd>Returns the string <code>"Math"</code>.</dd>
- <dt>{{jsxref("Global_Objects/Math/trunc", "Math.trunc(x)")}}</dt>
- <dd>Returns the integral part of the number x, removing any fractional digits.</dd>
-</dl>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.8', 'Math')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-math-object', 'Math')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>New methods {{jsxref("Math.log10()", "log10()")}}, {{jsxref("Math.log2()", "log2()")}}, {{jsxref("Math.log1p()", "log1p()")}}, {{jsxref("Math.expm1()", "expm1()")}}, {{jsxref("Math.cosh()", "cosh()")}}, {{jsxref("Math.sinh()", "sinh()")}}, {{jsxref("Math.tanh()", "tanh()")}}, {{jsxref("Math.acosh()", "acosh()")}}, {{jsxref("Math.asinh()", "asinh()")}}, {{jsxref("Math.atanh()", "atanh()")}}, {{jsxref("Math.hypot()", "hypot()")}}, {{jsxref("Math.trunc()", "trunc()")}}, {{jsxref("Math.sign()", "sign()")}}, {{jsxref("Math.imul()", "imul()")}}, {{jsxref("Math.fround()", "fround()")}}, {{jsxref("Math.cbrt()", "cbrt()")}} and {{jsxref("Math.clz32()", "clz32()")}} added.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-math-object', 'Math')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("Number")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/index.html
deleted file mode 100644
index 9ac8497a44..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/number/index.html
+++ /dev/null
@@ -1,213 +0,0 @@
----
-title: Number
-slug: Web/JavaScript/Reference/Global_Objects/Number
-tags:
-  - JavaScript
-  - Number
-  - Reference
-  - TopicStub
-translation_of: Web/JavaScript/Reference/Global_Objects/Number
----
-<div>{{JSRef}}</div>
-
-<p>O objecto JavaScript <strong><code>Number</code></strong> é um objecto abstraído que te permite trabalhar com valores numéricos. Um objecto <code>Number</code> é criado usando o constructor <code>Number().</code></p>
-
-<h2 id="Constructor">Constructor</h2>
-
-<pre class="syntaxbox">new Number(valor);</pre>
-
-<h3 id="Parâmetro">Parâmetro</h3>
-
-<dl>
- <dt><code>valor</code></dt>
- <dd>O valor numérico representado pelo objecto que está a ser criado.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Os usos mais comuns para o objecto <code>Number</code> são:</p>
-
-<ul>
- <li>Se o argumento não puder ser convertido num número, retorna {{jsxref("NaN")}}.</li>
- <li>Num contexto não-constructor (isto é, sem o operador {{jsxref("Operators/new", "new")}}), <code>Number</code> pode ser usado para uma conversão de tipo.</li>
-</ul>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<dl>
- <dt>{{jsxref("Number.EPSILON")}} {{experimental_inline}}</dt>
- <dd>O intervalo mais pequeno entre dois números representáveis.</dd>
- <dt>{{jsxref("Number.MAX_SAFE_INTEGER")}} {{experimental_inline}}</dt>
- <dd>O maior inteiro bem representado em JavaScript (<code>2<sup>53</sup> - 1</code>).</dd>
- <dt>{{jsxref("Number.MAX_VALUE")}}</dt>
- <dd>O maior número positivo representável.</dd>
- <dt>{{jsxref("Number.MIN_SAFE_INTEGER")}} {{experimental_inline}}</dt>
- <dd>O menor inteiro bem representado em JavaScript (<code>-(2<sup>53</sup> - 1)</code>).</dd>
- <dt>{{jsxref("Number.MIN_VALUE")}}</dt>
- <dd>O menor número positivo representável - ou seja, o número positivo mais próximo de zero (sem ser o zero).</dd>
- <dt>{{jsxref("Number.NaN")}}</dt>
- <dd>Valor especial para representar um "não número".</dd>
- <dt>{{jsxref("Number.NEGATIVE_INFINITY")}}</dt>
- <dd>Valor especial para representar o infinito negativo; retornado em caso de overflow.</dd>
- <dt>{{jsxref("Number.POSITIVE_INFINITY")}}</dt>
- <dd>Valor especial para representar o infinito; retornado em caso de overflow.</dd>
- <dt>{{jsxref("Number.prototype")}}</dt>
- <dd>Permite adicionar propriedades ao objecto <code>Number</code>.</dd>
-</dl>
-
-<h2 id="Métodos">Métodos</h2>
-
-<dl>
- <dt>{{jsxref("Number.isNaN()")}} {{experimental_inline}}</dt>
- <dd>Determina se o valor passado é NaN.</dd>
- <dt>{{jsxref("Number.isFinite()")}} {{experimental_inline}}</dt>
- <dd>Determina se o valor passado é um número finito.</dd>
- <dt>{{jsxref("Number.isInteger()")}} {{experimental_inline}}</dt>
- <dd>Determina se o número passado é um inteiro.</dd>
- <dt>{{jsxref("Number.isSafeInteger()")}} {{experimental_inline}}</dt>
- <dd>Determina se o valor passado é um inteiro bem representado (número entre <code>-(2<sup>53</sup> - 1)</code> e <code>2<sup>53</sup> - 1</code>).</dd>
- <dt><s class="obsoleteElement">{{jsxref("Number.toInteger()")}} {{obsolete_inline}}</s></dt>
- <dd><s class="obsoleteElement">Usado para avaliar o valor passado e convertê-lo num inteiro (ou {{jsxref("Global_Objects/Infinity", "Infinity")}}), mas foi removido.</s></dd>
- <dt>{{jsxref("Number.parseFloat()")}} {{experimental_inline}}</dt>
- <dd>O valor é o mesmo que {{jsxref("Global_Objects/parseFloat", "parseFloat()")}} de um objecto global.</dd>
- <dt>{{jsxref("Number.parseInt()")}} {{experimental_inline}}</dt>
- <dd>O valor é o mesmo que {{jsxref("Global_Objects/parseInt", "parseInt()")}} de um objecto global.</dd>
-</dl>
-
-<h2 id="Instâncias_de_Number"><code>Instâncias de Number</code></h2>
-
-<p>Todas as instâncias de <code>Number </code>herdam de {{jsxref("Number.prototype")}}. O objecto protótipo (prototype) do constructor de <code>Number</code> pode ser modificado para afectar todas as instâncias de <code>Number</code>.</p>
-
-<h3 id="Métodos_2">Métodos</h3>
-
-<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/prototype', 'Methods')}}</div>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usar_o_objecto_Number_para_atribuír_valores_a_variáveis_numéricas">Usar  o objecto <code>Number </code>para atribuír valores a variáveis numéricas</h3>
-
-<p>O seguinte exemplo usa as propriedades do objecto <code>Number</code> para atribuír valores a várias variáveis numéricas: </p>
-
-<pre class="brush: js">var biggestNum = Number.MAX_VALUE;
-var smallestNum = Number.MIN_VALUE;
-var infiniteNum = Number.POSITIVE_INFINITY;
-var negInfiniteNum = Number.NEGATIVE_INFINITY;
-var notANum = Number.NaN;
-</pre>
-
-<h3 id="Limite_inteiro_para_Number"><code>Limite inteiro para Number</code></h3>
-
-<p>O seguinte exemplo mostra o mínimo e máximo valores inteiros que podem ser representados como um objecto <code>Number</code> (para mais detalhes, consulta o standard do ECMAScript, capítulo <em>8.5 The Number Type</em>):</p>
-
-<pre class="brush: js">var biggestInt = 9007199254740992;
-var smallestInt = -9007199254740992;
-</pre>
-
-<p>Ao analisar dados que foram serializados para JSON, os valores inteiros fora deste limite são expectáveis de ficar corrompidos quando o analisador de JSON os tentar converter para o tipo <code>Number</code>. Como possível alternativa, usa {{jsxref("String")}}.</p>
-
-<h3 id="Usar_Number_para_converter_um_objecto_Date">Usar <code>Number </code>para converter um objecto <code>Date</code></h3>
-
-<p>O seguinte exemplo converte o objecto {{jsxref("Date")}} num valor numérico usando <code>Number</code> como função:</p>
-
-<pre class="brush: js">var d = new Date('December 17, 1995 03:24:00');
-console.log(Number(d));
-</pre>
-
-<p>Este código imprime "819199440000".</p>
-
-<h3 id="Converter_strings_numéricas_para_números">Converter strings numéricas para números</h3>
-
-<pre class="brush: js">Number("123")     // 123
-Number("")        // 0
-Number("0x11")    // 17
-Number("0b11")    // 3
-Number("0o11")    // 9
-Number("foo")     // NaN
-Number("100a")    // NaN
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Definição inicial. Implementado em JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7', 'Number')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number-objects', 'Number')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Adicionados novas propriedades e métodos: ({{jsxref("Number.EPSILON", "EPSILON")}}, {{jsxref("Number.isFinite", "isFinite")}}, {{jsxref("Number.isInteger", "isInteger")}}, {{jsxref("Number.isNaN", "isNaN")}}, {{jsxref("Number.parseFloat", "parseFloat")}}, {{jsxref("Number.parseInt", "parseInt")}})</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("NaN")}}</li>
- <li>The {{jsxref("Math")}} global object</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/isfinite/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/isfinite/index.html
deleted file mode 100644
index 9b70ca6a98..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/number/isfinite/index.html
+++ /dev/null
@@ -1,126 +0,0 @@
----
-title: Number.isFinite()
-slug: Web/JavaScript/Reference/Global_Objects/Number/isFinite
-tags:
-  - Experimental
-  - Finite
-  - JavaScript
-  - Method
-  - Método(2)
-  - Number
-  - Reference
-translation_of: Web/JavaScript/Reference/Global_Objects/Number/isFinite
----
-<div>{{JSRef}}</div>
-
-<p>O método <strong><code>Number.isFinite()</code></strong> determina se o valor passado é um número finito.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code>Number.isFinite(valor)</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>valor</code></dt>
- <dd>O valor a ser testado.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Em comparação com a função global {{jsxref("Global_Objects/isFinite", "isFinite()")}}, <strong><code>Number.isFinite()</code></strong> não converte forçosamente o parâmetro num number. Isto significa que apenas para valores do tipo number, finitos, retorna <code>true</code>.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<pre class="brush: js">Number.isFinite(Infinity);  // false
-Number.isFinite(NaN);       // false
-Number.isFinite(-Infinity); // false
-
-Number.isFinite(0);         // true
-Number.isFinite(2e64);      // true
-
-Number.isFinite('0');       // false, teria sido true com a função
-                            // global isFinite('0')
-</pre>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<pre class="brush: js">Number.isFinite = Number.isFinite || function(value) {
-    return typeof value === "number" &amp;&amp; isFinite(value);
-}
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.isfinite', 'Number.isInteger')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Initial definition.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatChrome("19")}}</td>
-   <td>{{CompatGeckoDesktop("16")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatOpera("15")}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile("16")}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>O objecto {{jsxref("Global_Objects/Number", "Number")}} ao qual pertence.</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/isinteger/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/isinteger/index.html
deleted file mode 100644
index 8c6dc79bb7..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/number/isinteger/index.html
+++ /dev/null
@@ -1,125 +0,0 @@
----
-title: Number.isInteger()
-slug: Web/JavaScript/Reference/Global_Objects/Number/isInteger
-tags:
-  - Experimental
-  - JavaScript
-  - Method
-  - Método(2)
-  - Number
-  - Reference
-translation_of: Web/JavaScript/Reference/Global_Objects/Number/isInteger
----
-<div>{{JSRef}}</div>
-
-<p>O método <strong><code>Number.isInteger()</code></strong> determina se o valor passado é um inteiro.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code>Number.isInteger(valor)</code></pre>
-
-<h3 id="Parâmteros">Parâmteros</h3>
-
-<dl>
- <dt><code>valor</code></dt>
- <dd>O valor a ser testado por ser um inteiro.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Se o valor a ser testado for um inteiro, retorna <code>true</code>, senão retorna <code>false</code>. Se o valor for {{jsxref("Global_Objects/NaN", "NaN")}} ou infinito, retorna <code>false</code>.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<pre class="brush: js">Number.isInteger(0.1);     // false
-Number.isInteger(1);       // true
-Number.isInteger(Math.PI); // false
-Number.isInteger(-100000); // true
-Number.isInteger(NaN);     // false
-Number.isInteger(0);       // true
-Number.isInteger("10");    // false
-</pre>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<pre class="brush: js">Number.isInteger = Number.isInteger || function(value) {
-    return typeof value === "number" &amp;&amp;
-           isFinite(value) &amp;&amp;
-           Math.floor(value) === value;
-};
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.isinteger', 'Number.isInteger')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoDesktop("16")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatGeckoMobile("16")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>O objecto {{jsxref("Global_Objects/Number", "Number")}} ao qual pertence.</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/isnan/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/isnan/index.html
deleted file mode 100644
index 0b242adbbe..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/number/isnan/index.html
+++ /dev/null
@@ -1,136 +0,0 @@
----
-title: Number.isNaN()
-slug: Web/JavaScript/Reference/Global_Objects/Number/isNaN
-tags:
-  - ECMAScript6
-  - Experimental
-  - JavaScript
-  - Method
-  - Método(2)
-  - Number
-translation_of: Web/JavaScript/Reference/Global_Objects/Number/isNaN
----
-<div>{{JSRef}}</div>
-
-<p>O método <strong><code>Number.isNaN()</code></strong> determina se o valor passado é {{jsxref("Global_Objects/NaN", "NaN")}}. Esta é uma versão mais robusta que {{jsxref("Global_Objects/isNaN", "isNaN()")}}.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code>Number.isNaN(valor)</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>valor</code></dt>
- <dd>O valor a ser testado se é {{jsxref("Global_Objects/NaN", "NaN")}}.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Due to both equality operators, {{jsxref("Operators/Comparison_Operators", "==", "#Equality")}} and {{jsxref("Operators/Comparison_Operators", "===", "#Identity")}}, evaluating to <code>false</code> when checking if {{jsxref("Global_Objects/NaN", "NaN")}} <em>is</em> {{jsxref("Global_Objects/NaN", "NaN")}}, the function <code>Number.isNaN()</code> has become necessary. This situation is unlike all other possible value comparisons in JavaScript.</p>
-
-<p>In comparison to the global {{jsxref("Global_Objects/isNaN", "isNaN()")}} function, <code>Number.isNaN()</code> doesn't suffer the problem of forcefully converting the parameter to a number. This means it is now safe to pass values that would normally convert to {{jsxref("Global_Objects/NaN", "NaN")}}, but aren't actually the same value as {{jsxref("Global_Objects/NaN", "NaN")}}. This also means that only values of the type number, that are also {{jsxref("Global_Objects/NaN", "NaN")}}, return <code>true</code>.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<pre class="brush: js">Number.isNaN(NaN);        // true
-Number.isNaN(Number.NaN); // true
-Number.isNaN(0 / 0)       // true
-
-// e.g. these would have been true with global isNaN()
-Number.isNaN("NaN");      // false
-Number.isNaN(undefined);  // false
-Number.isNaN({});         // false
-Number.isNaN("blabla");   // false
-
-// These all return false
-Number.isNaN(true);
-Number.isNaN(null);
-Number.isNaN(37);
-Number.isNaN("37");
-Number.isNaN("37.37");
-Number.isNaN("");
-Number.isNaN(" ");
-</pre>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<pre class="brush: js">Number.isNaN = Number.isNaN || function(value) {
-    return typeof value === "number" &amp;&amp; isNaN(value);
-}</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.isnan', 'Number.isnan')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatChrome("25")}}</td>
-   <td>{{CompatGeckoDesktop("15")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>9</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile("15")}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>iOS 9+</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("Global_Objects/Number", "Number")}}</li>
- <li>{{jsxref("Global_Objects/isNaN", "isNaN()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/max_value/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/max_value/index.html
deleted file mode 100644
index cd1666ecbc..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/number/max_value/index.html
+++ /dev/null
@@ -1,119 +0,0 @@
----
-title: Number.MAX_VALUE
-slug: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
-tags:
-  - JavaScript
-  - Number
-  - Property
-  - Propriedade
-translation_of: Web/JavaScript/Reference/Global_Objects/Number/MAX_VALUE
----
-<div>{{JSRef}}</div>
-
-<p>A propriedade <strong><code>Number.MAX_VALUE </code></strong>representa o máximo valor numérico representável em JavaScript.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>A propriedade <code>MAX_VALUE</code> tem um valor aproximado de <code>1.79E+308</code>. Valores maiores do que <code>MAX_VALUE</code> são representados como "<code>Infinity</code>".</p>
-
-<p>Dado que <code>MAX_VALUE</code> é uma propriedade estática (static) de {{jsxref("Number")}}, tu deves sempre usá-la na forma <code>Number.MAX_VALUE</code>, em vez de na forma de uma propriedade de um objecto {{jsxref("Number")}}  que tenhas criado.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_MAX_VALUE">Usando <code>MAX_VALUE</code></h3>
-
-<p>O seguinte código multiplica dois valores numéricos. Se o resultado for inferior ou igual a <code>MAX_VALUE</code>, a função <code>func1</code> é chamada; senão será chamada a função <code>func2</code>.</p>
-
-<pre class="brush: js">if (num1 * num2 &lt;= Number.MAX_VALUE) {
-  func1();
-} else {
-  func2();
-}
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Definição inicial. Implementado em JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.3.2', 'Number.MAX_VALUE')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.max_value', 'Number.MAX_VALUE')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("Number.MIN_VALUE")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/min_value/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/min_value/index.html
deleted file mode 100644
index 852b37426b..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/number/min_value/index.html
+++ /dev/null
@@ -1,121 +0,0 @@
----
-title: Number.MIN_VALUE
-slug: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
-tags:
-  - JavaScript
-  - Number
-  - Property
-  - Propriedade
-translation_of: Web/JavaScript/Reference/Global_Objects/Number/MIN_VALUE
----
-<div>{{JSRef}}</div>
-
-<p>A propriedade <strong><code>Number.MIN_VALUE </code></strong>representa o mínimo valor numérico representável em JavaScript.</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>A propriedade <code>MIN_VALUE</code> representa o valor mais próximo de 0 (zero), não negativo, que o JavaScript consegue representar.</p>
-
-<p>A propriedade <code>MIN_VALUE</code> tem um valor aproximado de <code>5e-324</code>. Valores menores do que <code>MIN_VALUE </code>("underflow values") são são convertidos para 0 (zero).</p>
-
-<p>Dado que <code>MIN_VALUE</code> é uma propriedade estática (static) de {{jsxref("Number")}}, tu deves sempre usá-la na forma <code>Number.MIN_VALUE</code>, em vez de na forma de uma propriedade de um objecto {{jsxref("Number")}} que tenhas criado.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_MIN_VALUE">Usando <code>MIN_VALUE</code></h3>
-
-<p>O seguinte código divide dois valores numéricos. Se o resultado for superior ou igual a <code>MIN_VALUE</code>, a função <code>func1</code> é chamada; senão será chamada a função <code>func2</code>.</p>
-
-<pre class="brush: js">if (num1 / num2 &gt;= Number.MIN_VALUE) {
-  func1();
-} else {
-  func2();
-}
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.3.3', 'Number.MIN_VALUE')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.min_value', 'Number.MIN_VALUE')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("Number.MAX_VALUE")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/nan/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/nan/index.html
deleted file mode 100644
index c3213486b7..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/number/nan/index.html
+++ /dev/null
@@ -1,103 +0,0 @@
----
-title: Number.NaN
-slug: Web/JavaScript/Reference/Global_Objects/Number/NaN
-tags:
-  - JavaScript
-  - Number
-  - Property
-  - Propriedade
-translation_of: Web/JavaScript/Reference/Global_Objects/Number/NaN
----
-<div>{{JSRef}}</div>
-
-<p>A propriedade <strong><code>Number.NaN </code></strong>representa um Não-Número. Equivalente a {{jsxref("NaN")}}.</p>
-
-<p>Não precisas de criar um objecto {{jsxref("Number")}} para aceder a esta propriedade estática (static) (usa <code>Number.NaN</code>).</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Definição inicial. Implementado no JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.3.4', 'Number.NaN')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.nan', 'Number.NaN')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>O objecto global {{jsxref("NaN")}}.</li>
- <li>O objecto {{jsxref("Number")}} ao qual pertence.</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/negative_infinity/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/negative_infinity/index.html
deleted file mode 100644
index a2a7d0f962..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/number/negative_infinity/index.html
+++ /dev/null
@@ -1,91 +0,0 @@
----
-title: Number.NEGATIVE_INFINITY
-slug: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY
-tags:
-  - JavaScript
-  - Number
-  - Propriedade
-  - Referencia
-translation_of: Web/JavaScript/Reference/Global_Objects/Number/NEGATIVE_INFINITY
----
-<div>{{JSRef}}</div>
-
-<p>A propriedade <strong><code>Number.NEGATIVE_INFINITY</code></strong> representa o valor negativo Infinito.</p>
-
-<p>Não tem de criar um objecto {{jsxref("Number")}} para aceder a esta propriedade estática (usa <code>Number.NEGATIVE_INFINITY</code>).</p>
-
-<div>{{js_property_attributes(0, 0, 0)}}</div>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O valor de <code>Number.NEGATIVE_INFINITY</code> é o mesmo que o valor negativo da propriedade {{jsxref("Infinity")}} do objeto global.</p>
-
-<p>Este valor comporta-se de forma ligeiramente diferente do infinito matemático:</p>
-
-<ul>
- <li>Qualquer valor positivo, incluindo {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, multiplicado por <code>NEGATIVE_INFINITY</code> é igual a <code>NEGATIVE_INFINITY</code>.</li>
- <li>Qualquer valor negativo, incluindo,<code>NEGATIVE_INFINITY</code> multiplicado por <code>NEGATIVE_INFINITY</code> é igual a {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li>
- <li>O valor 0 (zero) multiplicado por <code>NEGATIVE_INFINITY</code> é igual a {{jsxref("NaN")}}.</li>
- <li>{{jsxref("NaN")}} multiplicado por <code>NEGATIVE_INFINITY</code> é igual a {{jsxref("NaN")}}.</li>
- <li><code>NEGATIVE_INFINITY</code>, dividido por qualquer valor negativo excepto <code>NEGATIVE_INFINITY</code>, é igual a {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}.</li>
- <li><code>NEGATIVE_INFINITY</code>, dividido por qualquer valor positivo exceto {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, é igual a <code>NEGATIVE_INFINITY</code>.</li>
- <li><code>NEGATIVE_INFINITY</code>, dividido por outro <code>NEGATIVE_INFINITY</code> ou {{jsxref("Number.POSITIVE_INFINITY", "POSITIVE_INFINITY")}}, é igual a {{jsxref("NaN")}}.</li>
- <li>Qualquer número dividido por <code>NEGATIVE_INFINITY</code> é igual a 0 (zero).</li>
-</ul>
-
-<p>Pode usar a propriedade <code>Number.NEGATIVE_INFINITY</code> para indicar uma condição de erro numa situação em que, no caso de sucesso, é retornado um valor finito.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_NEGATIVE_INFINITY">Usando <code>NEGATIVE_INFINITY</code></h3>
-
-<p>No seguinte exemplo, é atribuído à variável <code>smallNumber</code> um valor inferior ao valor mínimo. Quando a linha de código {{jsxref("Statements/if...else", "if")}} é executada, a variável <code>smallNumber</code> tem o valor <code>-Infinity</code>, então é atribuída à mesma variável um valor finito antes de continuar.</p>
-
-<pre class="brush: js notranslate">var smallNumber = (-Number.MAX_VALUE) * 2;
-
-if (smallNumber == Number.NEGATIVE_INFINITY) {
-  smallNumber = returnFinite();
-}
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.3.5', 'Number.NEGATIVE_INFINITY')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.negative_infinity', 'Number.NEGATIVE_INFINITY')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td></td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade">Compatibilidade</h2>
-
-<p class="hidden">The compatibility table in this page is generated from structured data. If you'd like to contribute to the data, please check out <a href="https://github.com/mdn/browser-compat-data">https://github.com/mdn/browser-compat-data</a> and send us a pull request.</p>
-
-<p>{{Compat("javascript.builtins.Number.NEGATIVE_INFINITY")}}</p>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("Number.POSITIVE_INFINITY")}}</li>
- <li>{{jsxref("Number.isFinite()")}}</li>
- <li>{{jsxref("Global_Objects/Infinity", "Infinity")}}</li>
- <li>{{jsxref("Global_Objects/isFinite", "isFinite()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/number/tostring/index.html b/files/pt-pt/web/javascript/reference/global_objects/number/tostring/index.html
deleted file mode 100644
index 1ff4892314..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/number/tostring/index.html
+++ /dev/null
@@ -1,146 +0,0 @@
----
-title: Number.prototype.toString()
-slug: Web/JavaScript/Reference/Global_Objects/Number/toString
-tags:
-  - JavaScript
-  - Number
-  - Prototype
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Number/toString
----
-<div>{{JSRef}}</div>
-
-<p>O método <strong><code>toString()</code></strong> retorna  uma string com o valor do objecto {{jsxref("Number")}} especificado.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><var>numObj</var>.toString([<var>radix</var>])</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>base</code></dt>
- <dd>Opcional. Um inteiro entre [2, 36] especificando a base usada para representar o valor númerico.</dd>
-</dl>
-
-<h3 id="Erros_possíveis">Erros possíveis</h3>
-
-<dl>
- <dt>{{jsxref("RangeError")}}</dt>
- <dd>Se o valor do parâmetro base não estiver entre [2, 36], o erro {{jsxref("RangeError")}} é lançado.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O objecto {{jsxref("Number")}} faz override ao método <code>toString()</code> do objecto {{jsxref("Object")}}; não herda de {{jsxref("Object.prototype.toString()")}}. Para os objectos {{jsxref( "Number")}}, o método <code>toString() </code>retorna uma representação em string do ojecto na base especificada.</p>
-
-<p>O método <code>toString() </code>analisa o seu primeiro argumento e tenta retornar uma representação em string na base especificada. Para bases superiores a 10, as letras do alfabeto representam numerais maiores do que 9 (por ordem alfabética: a, b, c ...). Por exemplo, para números hexadecimais (base 16) são usadasa as letras do alfabeto até <code>f</code>.</p>
-
-<p>Se a <code>base </code>não for especificada, o seu valor assumido é 10.</p>
-
-<p>Se o <code><var>numObj </var></code>tem um valor negativo (&lt; 0), o sinal é preservado. O mesmo se aplica se a base tiver o valor 2; a string retornada é a representação positiva do binário de <code><var>numObj </var></code>precedida pelo sinal negativo (-), e não complement para 2 de <code>numObj</code>.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_toString">Usando <code>toString</code></h3>
-
-<pre class="brush: js">var count = 10;
-
-console.log(count.toString());    // imprime '10'
-console.log((17).toString());     // imprime '17'
-
-var x = 6;
-
-console.log(x.toString(2));       // imprime '110'
-console.log((254).toString(16));  // imprime 'fe'
-
-console.log((-10).toString(2));   // imprime '-1010'
-console.log((-0xff).toString(2)); // imprime'-11111111'
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Definição inicial. Implementado em JavaScript 1.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.7.4.2', 'Number.prototype.tostring')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-number.prototype.tostring', 'Number.prototype.tostring')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>BSuporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("Number.prototype.toFixed()")}}</li>
- <li>{{jsxref("Number.prototype.toExponential()")}}</li>
- <li>{{jsxref("Number.prototype.toPrecision()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/object/hasownproperty/index.html b/files/pt-pt/web/javascript/reference/global_objects/object/hasownproperty/index.html
deleted file mode 100644
index 2c91823404..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/object/hasownproperty/index.html
+++ /dev/null
@@ -1,187 +0,0 @@
----
-title: Object.prototype.hasOwnProperty()
-slug: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
-tags:
-  - JavaScript
-  - Objeto
-  - Prototipo
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/Object/hasOwnProperty
----
-<div>{{JSRef}}</div>
-
-<p>O método <code><strong>hasOwnProperty()</strong></code> retorna um booleano indicando se o objeto tem a propriedade especificada.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><var>obj</var>.hasOwnProperty(<var>prop</var>)</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>prop</code></dt>
- <dd>O nome da propriedade para testar.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Cada objecto descendente de {{jsxref("Object")}} herda o método <code>hasOwnProperty</code>. Este método pode ser usado para determinar se um objecto contém a propriedade especificada como uma propriedade direta desse objeto; ao contrário do operador {{jsxref("Operators/in", "in")}}, este método não verifica a cadeia de objetos do protótipo.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_hasOwnProperty_para_testar_a_existência_de_uma_propriedade">Usando <code>hasOwnProperty</code> para testar a existência de uma propriedade</h3>
-
-<p>O seguinte exemplo determina se o objecto "o" contém a propriedade "<code>prop"</code>:</p>
-
-<pre class="brush: js">o = new Object();
-o.prop = 'existe';
-
-function changeO() {
-  o.newprop = o.prop;
-  delete o.prop;
-}
-
-o.hasOwnProperty('prop');   // retorna true
-changeO();
-o.hasOwnProperty('prop');   // retorna false
-</pre>
-
-<h3 id="Direto_versus_propriedades_herdadas">Direto versus propriedades herdadas</h3>
-
-<p>O seguinte exemplo diferencia entre propriedades diretas e propriedades herdadas através da cadeia de protótipos:</p>
-
-<pre class="brush: js">o = new Object();
-o.prop = 'existe';
-o.hasOwnProperty('prop');             // retorna true
-o.hasOwnProperty('toString');         // retorna false
-o.hasOwnProperty('hasOwnProperty');   // retorna false
-</pre>
-
-<h3 id="Iteração_entre_as_propriedades_de_um_objeto">Iteração entre as propriedades de um objeto</h3>
-
-<p>O seguinte exemplo mostra como iterar entre as propriedades de um objeto sem executar em propriedades herdadas. Note que o ciclo {{jsxref("Statements/for...in", "for...in")}}  já está apenas repetindo itens enumeráveis então um não devia assumir baseado na falta de propriedades não-enumeráveis mostrado no ciclo que <code>hasOwnProperty</code> em si é estritamente limitado aos itens enumeráveis (como com {{jsxref("Object.getOwnPropertyNames()")}}).</p>
-
-<pre class="brush: js">var buz = {
-  fog: 'stack'
-};
-
-for (var name in buz) {
-  if (buz.hasOwnProperty(name)) {
-    console.log('Isto é fog (' + name + ') com certeza. Valor: ' + buz[name]);
-  }
-  else {
-    console.log(name); // toString ou outra coisa
-  }
-}
-</pre>
-
-<h3 id="Usando_hasOwnProperty_como_um_nome_de_uma_propriedade">Usando <code>hasOwnProperty</code> como um nome de uma propriedade</h3>
-
-<p>JavaScript não protege a propriedade <code>hasOwnProperty</code>; assim, se a possibilidade existe de um objeto poder ter uma propriedade com este nome, é necessário usar um <code>hasOwnProperty</code> externo para obter resultados corretos:</p>
-
-<pre class="brush: js">var foo = {
-  hasOwnProperty: function() {
-    return false;
-  },
-  bar: 'Aqui os dragões'
-};
-
-foo.hasOwnProperty('bar'); // sempre retornará false
-
-// Use outro objeto hasOwnProperty e chame-o com 'this' definido como foo
-({}).hasOwnProperty.call(foo, 'bar'); // true
-
-// É também possível usar a propriedade hasOwnProperty através do protótipo do objeto para este propósito
-Object.prototype.hasOwnProperty.call(foo, 'bar'); // true
-</pre>
-
-<p>Note que no último caso, não há objetos recém-criados.</p>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES3')}}</td>
-   <td>{{Spec2('ES3')}}</td>
-   <td>Definição inicial. Implementado em JavaScript 1.5.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.2.4.5', 'Object.prototype.hasOwnProperty')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-object.prototype.hasownproperty', 'Object.prototype.hasOwnProperty')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_entre_browsers">Compatibilidade entre browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Característica</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Característica</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li><a href="/en-US/docs/Enumerability_and_ownership_of_properties">Enumerabilidade e posse de propriedades</a></li>
- <li>{{jsxref("Object.getOwnPropertyNames()")}}</li>
- <li>{{jsxref("Statements/for...in", "for...in")}}</li>
- <li>{{jsxref("Operators/in", "in")}}</li>
- <li><a href="/en-US/docs/Web/JavaScript/Guide/Inheritance_Revisited">Guia JavaScript: Herança e a cadeia de protótipos</a></li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/object/index.html b/files/pt-pt/web/javascript/reference/global_objects/object/index.html
deleted file mode 100644
index e393f833b8..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/object/index.html
+++ /dev/null
@@ -1,184 +0,0 @@
----
-title: Object
-slug: Web/JavaScript/Reference/Global_Objects/Object
-tags:
-  - Constructor
-  - Construtor
-  - JavaScript
-  - Object
-  - Objeto
-translation_of: Web/JavaScript/Reference/Global_Objects/Object
----
-<div>{{JSRef}}</div>
-
-<p>o construtor <code><strong>Object</strong></code> cria um wrapper de objeto.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox">// Object initialiser or literal
-{ [ <var>nameValuePair1</var>[, <var>nameValuePair2</var>[, ...<var>nameValuePairN</var>] ] ] }
-
-// Called as a constructor
-new Object([<var>value</var>])</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>nameValuePair1, nameValuePair2, ... nameValuePair<em>N</em></code></dt>
- <dd>Pairs of names (strings) and values (any value) where the name is separated from the value by a colon.</dd>
- <dt><code>value</code></dt>
- <dd>Any value.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>The <code>Object</code> constructor creates an object wrapper for the given value. If the value is {{jsxref("null")}} or {{jsxref("undefined")}}, it will create and return an empty object, otherwise, it will return an object of a Type that corresponds to the given value. If the value is an object already, it will return the value.</p>
-
-<p>When called in a non-constructor context, <code>Object</code> behaves identically to <code>new Object()</code>.</p>
-
-<p>See also the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Object_initializer">object initializer / literal syntax</a>.</p>
-
-<h2 id="Propriedades_de_um_construtor_Object">Propriedades de um construtor <code>Object</code></h2>
-
-<dl>
- <dt><code>Object.length</code></dt>
- <dd>Tem um valor de 1.</dd>
- <dt>{{jsxref("Object.prototype")}}</dt>
- <dd>Permite a adição de propriedades para todos os objetos do tipo <em>Object</em>.</dd>
-</dl>
-
-<h2 id="Métodos_de_um_construtor_Object">Métodos de um construtor <code>Object</code></h2>
-
-<dl>
- <dt>{{jsxref("Object.assign()")}}</dt>
- <dd>Copies the values of all enumerable own properties from one or more source objects to a target object.</dd>
- <dt>{{jsxref("Object.create()")}}</dt>
- <dd>Creates a new object with the specified prototype object and properties.</dd>
- <dt>{{jsxref("Object.defineProperty()")}}</dt>
- <dd>Adds the named property described by a given descriptor to an object.</dd>
- <dt>{{jsxref("Object.defineProperties()")}}</dt>
- <dd>Adds the named properties described by the given descriptors to an object.</dd>
- <dt>{{jsxref("Object.entries()")}}</dt>
- <dd>Returns an array containing all of the <code>[key, value]</code> pairs of a given object's <strong>own</strong> enumerable string properties.</dd>
- <dt>{{jsxref("Object.freeze()")}}</dt>
- <dd>Freezes an object: other code can't delete or change any properties.</dd>
- <dt>{{jsxref("Object.fromEntries()")}}</dt>
- <dd>Returns a new object from an iterable of key-value pairs (reverses {{jsxref("Object.entries")}}).</dd>
- <dt>{{jsxref("Object.getOwnPropertyDescriptor()")}}</dt>
- <dd>Returns a property descriptor for a named property on an object.</dd>
- <dt>{{jsxref("Object.getOwnPropertyDescriptors()")}}</dt>
- <dd>Returns an object containing all own property descriptors for an object.</dd>
- <dt>{{jsxref("Object.getOwnPropertyNames()")}}</dt>
- <dd>Returns an array containing the names of all of the given object's <strong>own</strong> enumerable and non-enumerable properties.</dd>
- <dt>{{jsxref("Object.getOwnPropertySymbols()")}}</dt>
- <dd>Returns an array of all symbol properties found directly upon a given object.</dd>
- <dt>{{jsxref("Object.getPrototypeOf()")}}</dt>
- <dd>Returns the prototype of the specified object.</dd>
- <dt>{{jsxref("Object.is()")}}</dt>
- <dd>Compares if two values are the same value. Equates all NaN values (which differs from both Abstract Equality Comparison and Strict Equality Comparison).</dd>
- <dt>{{jsxref("Object.isExtensible()")}}</dt>
- <dd>Determines if extending of an object is allowed.</dd>
- <dt>{{jsxref("Object.isFrozen()")}}</dt>
- <dd>Determines if an object was frozen.</dd>
- <dt>{{jsxref("Object.isSealed()")}}</dt>
- <dd>Determines if an object is sealed.</dd>
- <dt>{{jsxref("Object.keys()")}}</dt>
- <dd>Returns an array containing the names of all of the given object's <strong>own</strong> enumerable string properties.</dd>
- <dt>{{jsxref("Object.preventExtensions()")}}</dt>
- <dd>Prevents any extensions of an object.</dd>
- <dt>{{jsxref("Object.seal()")}}</dt>
- <dd>Prevents other code from deleting properties of an object.</dd>
- <dt>{{jsxref("Object.setPrototypeOf()")}}</dt>
- <dd>Sets the prototype (i.e., the internal <code>[[Prototype]]</code> property).</dd>
- <dt>{{jsxref("Object.values()")}}</dt>
- <dd>Returns an array containing the values that correspond to all of a given object's <strong>own</strong> enumerable string properties.</dd>
-</dl>
-
-<h2 id="Instâcias_de_Object_e_objeto_protótipo_Object">Instâcias de <code>Object</code> e objeto protótipo <code>Object</code></h2>
-
-<p>All objects in JavaScript are descended from <code>Object</code>; all objects inherit methods and properties from {{jsxref("Object.prototype")}}, although they may be overridden. For example, other constructors' prototypes override the <code>constructor</code> property and provide their own <code>toString()</code> methods. Changes to the <code>Object</code> prototype object are propagated to all objects unless the properties and methods subject to those changes are overridden further along the prototype chain.</p>
-
-<h3 id="Propriedades">Propriedades</h3>
-
-<div>{{page('//pt-PT/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Propriedades') }}</div>
-
-<h3 id="Métodos">Métodos</h3>
-
-<div>{{page('//pt-PT/docs/Web/JavaScript/Reference/Global_Objects/Object/prototype', 'Métodos') }}</div>
-
-<h2 id="Deleting_a_property_from_an_object">Deleting a property from an object</h2>
-
-<p>There isn't any method in an Object itself to delete its own properties (e.g. like <code><a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map/delete">Map.prototype.delete()</a></code>). To do so one has to use the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/delete">delete operator</a>.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Using_Object_given_undefined_and_null_types">Using <code>Object</code> given <code>undefined</code> and <code>null</code> types</h3>
-
-<p>The following examples store an empty <code>Object</code> object in <code>o</code>:</p>
-
-<pre class="brush: js">var o = new Object();
-</pre>
-
-<pre class="brush: js">var o = new Object(undefined);
-</pre>
-
-<pre class="brush: js">var o = new Object(null);
-</pre>
-
-<h3 id="Using_Object_to_create_Boolean_objects">Using <code>Object</code> to create <code>Boolean</code> objects</h3>
-
-<p>The following examples store {{jsxref("Boolean")}} objects in <code>o</code>:</p>
-
-<pre class="brush: js">// equivalent to o = new Boolean(true);
-var o = new Object(true);
-</pre>
-
-<pre class="brush: js">// equivalent to o = new Boolean(false);
-var o = new Object(Boolean());
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition. Implemented in JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.2', 'Object')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-object-objects', 'Object')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Added Object.assign, Object.getOwnPropertySymbols, Object.setPrototypeOf, Object.is</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-object-objects', 'Object')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>Added Object.entries, Object.values and Object.getOwnPropertyDescriptors.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
-
-<div>
-
-
-<p>{{Compat("javascript.builtins.Object")}}</p>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li><a href="/pt-PT/docs/Web/JavaScript/Reference/Operadores/Inicializador_objeto">Inicializador de objeto</a></li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/string/index.html b/files/pt-pt/web/javascript/reference/global_objects/string/index.html
deleted file mode 100644
index 4ccc8f5f81..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/string/index.html
+++ /dev/null
@@ -1,326 +0,0 @@
----
-title: String
-slug: Web/JavaScript/Reference/Global_Objects/String
-tags:
-  - ECMAScript 2015
-  - JavaScript
-  - Referencia
-  - String
-translation_of: Web/JavaScript/Reference/Global_Objects/String
----
-<div>{{JSRef}}</div>
-
-<p>O objeto global <strong><code>String</code></strong> é um construtor de <em>strings</em> ou sequência de carateres.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<p>Os literais de string assumem as formas:</p>
-
-<pre class="syntaxbox"><code>'string text'
-"string text"
-"中文 español English हिन्दी العربية português বাংলা русский 日本語 ਪੰਜਾਬੀ 한국어 தமிழ்"</code></pre>
-
-<p>As Strings podem também ser criadas usando o objecto global string directamente:</p>
-
-<pre class="syntaxbox"><code>String(thing)
-new String(thing)</code></pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>thing</code></dt>
- <dd>Qualquer parâmetro para ser convertido numa <em>string</em>.</dd>
-</dl>
-
-<h3 id="Strings_modelo"><em>Strings </em>modelo</h3>
-
-<p>A partir de ECMAScript 2015, os literais de <em>strings</em> podem também ser chamados de <a href="/en-US/docs/Web/JavaScript/Reference/template_strings">Modelo strings</a>:</p>
-
-<pre class="brush: js"><code>`hello world`</code>
-`hello!
- world!`
-<code>`hello ${who}`</code>
-<code>escape `&lt;a&gt;${who}&lt;/a&gt;`</code></pre>
-
-<dl>
-</dl>
-
-<h3 id="Notação_Escape">Notação <em>Escape</em></h3>
-
-<p>Além dos carateres regulares e imprmiveis, os carateres especiais também podem ser codificados com notação <em>escape</em>:</p>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Código</th>
-   <th scope="col">Resultado</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td><code>\XXX</code> (<code>XXX</code> = 1 - 3 octal digits; range of 0 - 377)</td>
-   <td>ISO-8859-1 character / Unicode code point between U+0000 and U+00FF</td>
-  </tr>
-  <tr>
-   <td><code>\'</code></td>
-   <td>Aspas simples</td>
-  </tr>
-  <tr>
-   <td><code>\"</code></td>
-   <td>Aspas duplas</td>
-  </tr>
-  <tr>
-   <td><code>\\</code></td>
-   <td>Barra invertida</td>
-  </tr>
-  <tr>
-   <td><code>\n</code></td>
-   <td>Nova linha</td>
-  </tr>
-  <tr>
-   <td><code>\r</code></td>
-   <td>carriage return</td>
-  </tr>
-  <tr>
-   <td><code>\v</code></td>
-   <td>Tab vertical</td>
-  </tr>
-  <tr>
-   <td><code>\t</code></td>
-   <td>Tab</td>
-  </tr>
-  <tr>
-   <td><code>\b</code></td>
-   <td>backspace</td>
-  </tr>
-  <tr>
-   <td><code>\f</code></td>
-   <td>form feed</td>
-  </tr>
-  <tr>
-   <td><code>\uXXXX</code> (<code>XXXX</code> = 4 hex digits; range of 0x0000 - 0xFFFF)</td>
-   <td>UTF-16 code unit / Unicode code point between U+0000 and U+FFFF</td>
-  </tr>
-  <tr>
-   <td><code>\u{X}</code> ... <code>\u{XXXXXX}</code> (<code>X…XXXXXX</code> = 1 - 6 hex digits; range of 0x0 - 0x10FFFF)</td>
-   <td>UTF-32 code unit / Unicode code point between U+0000 and U+10FFFF {{experimental_inline}}</td>
-  </tr>
-  <tr>
-   <td><code>\xXX</code> (<code>XX</code> = 2 hex digits; range of 0x00 - 0xFF)</td>
-   <td>ISO-8859-1 character / Unicode code point between U+0000 and U+00FF</td>
-  </tr>
- </tbody>
-</table>
-
-<div class="note">
-<p><strong>Note: </strong>Ao contrário de algumas outras linguagens, o Javascript não faz distinção entre strings com aspas simples e aspas duplas; Portanto a notação "escape" funciona em strings independente se foi utilizada aspas simples, ou aspas duplas na criação.</p>
-</div>
-
-<h3 id="Strings_literais_longas"><em>Strings </em>literais longas</h3>
-
-<p>Sometimes, your code will include strings which are very long. Rather than having lines that go on endlessly, or wrap at the whim of your editor, you may wish to specifically break the string into multiple lines in the source code without affecting the actual string contents. There are two ways you can do this.</p>
-
-<p>You can use the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Addition_()">+</a> operator to append multiple strings together, like this:</p>
-
-<pre class="brush: js">let longString = "This is a very long string which needs " +
-                 "to wrap across multiple lines because " +
-                 "otherwise my code is unreadable.";
-</pre>
-
-<p>Or you can use the backslash character ("\") at the end of each line to indicate that the string will continue on the next line. Make sure there is no space or any other character after the backslash (except for a line break), or as an indent; otherwise it will not work. That form looks like this:</p>
-
-<pre class="brush: js">let longString = "This is a very long string which needs \
-to wrap across multiple lines because \
-otherwise my code is unreadable.";
-</pre>
-
-<p>Both of these result in identical strings being created.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Strings are useful for holding data that can be represented in text form. Some of the most-used operations on strings are to check their {{jsxref("String.length", "length")}}, to build and concatenate them using the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/String_Operators">+ and += string operators</a>, checking for the existence or location of substrings with the {{jsxref("String.prototype.indexOf()", "indexOf()")}} method, or extracting substrings with the {{jsxref("String.prototype.substring()", "substring()")}} method.</p>
-
-<h3 id="Acesso_de_caráter">Acesso de caráter</h3>
-
-<p>There are two ways to access an individual character in a string. The first is the {{jsxref("String.prototype.charAt()", "charAt()")}} method:</p>
-
-<pre class="brush: js">return 'cat'.charAt(1); // returns "a"
-</pre>
-
-<p>The other way (introduced in ECMAScript 5) is to treat the string as an array-like object, where individual characters correspond to a numerical index:</p>
-
-<pre class="brush: js">return 'cat'[1]; // returns "a"
-</pre>
-
-<p>For character access using bracket notation, attempting to delete or assign a value to these properties will not succeed. The properties involved are neither writable nor configurable. (See {{jsxref("Object.defineProperty()")}} for more information.)</p>
-
-<h3 id="Comparação_de_strings">Comparação de <em>strings</em></h3>
-
-<p>C developers have the <code>strcmp()</code> function for comparing strings. In JavaScript, you just use the <a href="/en-US/docs/Web/JavaScript/Reference/Operators/Comparison_Operators">less-than and greater-than operators</a>:</p>
-
-<pre class="brush: js">var a = 'a';
-var b = 'b';
-if (a &lt; b) { // true
-  console.log(a + ' is less than ' + b);
-} else if (a &gt; b) {
-  console.log(a + ' is greater than ' + b);
-} else {
-  console.log(a + ' and ' + b + ' are equal.');
-}
-</pre>
-
-<p>A similar result can be achieved using the {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} method inherited by <code>String</code> instances.</p>
-
-<h3 id="Distinção_entre_string_primitivas_e_objetos_String">Distinção entre <em>string</em> primitivas e objetos <em><code>String</code></em></h3>
-
-<p>Note that JavaScript distinguishes between <code>String</code> objects and primitive string values. (The same is true of {{jsxref("Boolean")}} and {{jsxref("Global_Objects/Number", "Numbers")}}.)</p>
-
-<p>String literals (denoted by double or single quotes) and strings returned from <code>String</code> calls in a non-constructor context (i.e., without using the {{jsxref("Operators/new", "new")}} keyword) are primitive strings. JavaScript automatically converts primitives to <code>String</code> objects, so that it's possible to use <code>String</code> object methods for primitive strings. In contexts where a method is to be invoked on a primitive string or a property lookup occurs, JavaScript will automatically wrap the string primitive and call the method or perform the property lookup.</p>
-
-<pre class="brush: js">var a = 'a';
-var b = 'b';
-if (a &lt; b) { // true
-  console.log(a + ' is less than ' + b);
-} else if (a &gt; b) {
-  console.log(a + ' is greater than ' + b);
-} else {
-  console.log(a + ' and ' + b + ' are equal.');
-}
-</pre>
-
-<p>A similar result can be achieved using the {{jsxref("String.prototype.localeCompare()", "localeCompare()")}} method inherited by <code>String</code> instances.</p>
-
-<div class="blockIndicator note">
-<p>Nota: <code>a == b</code> compares the strings in a and b for being equal in the usual case-sensitive way. If you wish to compare without regard to upper or lower case characters, use a function similar to this:</p>
-
-<p><code>function isEqual(str1, str2)<br>
-     {<br>
-     return str1.toUpperCase()===str2.toUpperCase();<br>
-     } // isEqual</code></p>
-
-<p>Upper case is used instead of lower case in this function due to problems with certain UTF-8 character conversions.</p>
-</div>
-
-<h3 id="Distinção_entre_string_primitivas_e_objetos_String_2">Distinção entre <em>string</em> primitivas e objetos <em><code>String</code></em></h3>
-
-<p>Note that JavaScript distinguishes between <code>String</code> objects and primitive string values. (The same is true of {{jsxref("Boolean")}} and {{jsxref("Global_Objects/Number", "Numbers")}}.)</p>
-
-<p>String literals (denoted by double or single quotes) and strings returned from <code>String</code> calls in a non-constructor context (i.e., without using the {{jsxref("Operators/new", "new")}} keyword) are primitive strings. JavaScript automatically converts primitives to <code>String</code> objects, so that it's possible to use <code>String</code> object methods for primitive strings. In contexts where a method is to be invoked on a primitive string or a property lookup occurs, JavaScript will automatically wrap the string primitive and call the method or perform the property lookup.</p>
-
-<pre class="brush: js">var s_prim = 'foo';
-var s_obj = new String(s_prim);
-
-console.log(typeof s_prim); // Logs "string"
-console.log(typeof s_obj);  // Logs "object"
-</pre>
-
-<p>String primitives and <code>String</code> objects also give different results when using {{jsxref("Global_Objects/eval", "eval()")}}. Primitives passed to <code>eval</code> are treated as source code; <code>String</code> objects are treated as all other objects are, by returning the object. For example:</p>
-
-<pre class="brush: js">var s1 = '2 + 2';             // creates a string primitive
-var s2 = new String('2 + 2'); // creates a String object
-console.log(eval(s1));        // returns the number 4
-console.log(eval(s2));        // returns the string "2 + 2"
-</pre>
-
-<p>For these reasons, the code may break when it encounters <code>String</code> objects when it expects a primitive string instead, although generally, authors need not worry about the distinction.</p>
-
-<p>A <code>String</code> object can always be converted to its primitive counterpart with the {{jsxref("String.prototype.valueOf()", "valueOf()")}} method.</p>
-
-<pre class="brush: js">console.log(eval(s2.valueOf())); // returns the number 4
-</pre>
-
-<div class="note"><strong>Nota:</strong> For another possible approach to strings in JavaScript, please read the article about <a href="/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — a C-like representation of strings based on typed arrays</a>.</div>
-
-<h2 id="Propriedades">Propriedades</h2>
-
-<dl>
- <dt>{{jsxref("String.prototype")}}</dt>
- <dd>Allows the addition of properties to a <code>String</code> object.</dd>
-</dl>
-
-<h2 id="Métodos">Métodos</h2>
-
-<dl>
- <dt>{{jsxref("String.fromCharCode()")}}</dt>
- <dd>Returns a string created by using the specified sequence of Unicode values.</dd>
- <dt>{{jsxref("String.fromCodePoint()")}}</dt>
- <dd>Returns a string created by using the specified sequence of code points.</dd>
- <dt>{{jsxref("String.raw()")}} {{experimental_inline}}</dt>
- <dd>Returns a string created from a raw template string.</dd>
-</dl>
-
-<h2 id="Instâncias_de_String">Instâncias de <em><code>String</code></em></h2>
-
-<h3 id="Propriedades_2">Propriedades</h3>
-
-<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Properties')}}</div>
-
-<h3 id="Métodos_2">Métodos</h3>
-
-<h4 id="Methods_unrelated_to_HTML">Methods unrelated to HTML</h4>
-
-<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'Methods_unrelated_to_HTML')}}</div>
-
-<h4 id="HTML_wrapper_methods">HTML wrapper methods</h4>
-
-<div>{{page('/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/prototype', 'HTML_wrapper_methods')}}</div>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Conversão_de_String">Conversão de <em>String</em></h3>
-
-<p>It's possible to use <code>String</code> as a more reliable {{jsxref("String.prototype.toString()", "toString()")}} alternative, as it works when used on {{jsxref("null")}}, {{jsxref("undefined")}}, and on {{jsxref("Symbol", "symbols")}}. For example:</p>
-
-<pre class="brush: js">var outputStrings = [];
-for (var i = 0, n = inputValues.length; i &lt; n; ++i) {
-  outputStrings.push(String(inputValues[i]));
-}
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <thead>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
- </thead>
- <tbody>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string-objects', 'String')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-string-objects', 'String')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5', 'String')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td></td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Initial definition.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegador">Compatibilidade de navegador</h2>
-
-
-
-<p>{{Compat("javascript.builtins.String",2)}}</p>
-
-<h2 id="Consulte_também">Consulte também:</h2>
-
-<ul>
- <li>{{domxref("DOMString")}}</li>
- <li><a href="/en-US/Add-ons/Code_snippets/StringView"><code>StringView</code> — a C-like representation of strings based on typed arrays</a></li>
- <li><a href="/en-US/docs/Web/API/DOMString/Binary">Binary strings</a></li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/string/indexof/index.html b/files/pt-pt/web/javascript/reference/global_objects/string/indexof/index.html
deleted file mode 100644
index 721fb3c913..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/string/indexof/index.html
+++ /dev/null
@@ -1,191 +0,0 @@
----
-title: String.prototype.indexOf()
-slug: Web/JavaScript/Reference/Global_Objects/String/indexOf
-tags:
-  - JavaScript
-  - Method
-  - Prototype
-  - Reference
-  - String
-translation_of: Web/JavaScript/Reference/Global_Objects/String/indexOf
----
-<div>{{JSRef}}</div>
-
-<p>O método <strong><code>indexOf()</code></strong> retorna o indíce da primeira ocorrência do valor especificado no objeto {{jsxref("String")}}, começando a procura a partir de <code>fromIndex</code>. Retorna -1 se o valor não for encontrado.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><var>str</var>.indexOf(<var>searchValue</var>[, <var>fromIndex</var>]</code>)</pre>
-
-<h3 id="Parâmetros">Parâmetros</h3>
-
-<dl>
- <dt><code>searchValue</code></dt>
- <dd>Uma string com o valor pelo qual se procura.</dd>
- <dt><code>fromIndex</code> {{optional_inline}}</dt>
- <dd>O ponto da string a partir do qual a procura deverá começar. Pode ter o valor de um qualquer inteiro. O valor por predefinição é 0. Se o <code>fromIndex &lt; 0</code> a procura é feita em toda a string (o mesmo que passar o valor 0). Se <code>fromIndex &gt;= str.length</code>, o método retornará -1, exceção feita quando o valor de <code>searchValue</code> é uma string vazia, nesse caso retorna <code>str.length</code>.</dd>
-</dl>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Os caractéres numa string são indexadas da esquerda para a direita. O índice do primeira caractér é 0, e o índice do último caractér da string, chamado de <code>stringName,</code> é <code>stringName.length - 1</code>.</p>
-
-<pre class="brush: js">'Blue Whale'.indexOf('Blue');     // retorna  0
-'Blue Whale'.indexOf('Blute');    // retorna -1
-'Blue Whale'.indexOf('Whale', 0); // retorna  5
-'Blue Whale'.indexOf('Whale', 5); // retorna  5
-'Blue Whale'.indexOf('', 9);      // retorna  9
-'Blue Whale'.indexOf('', 10);     // retorna 10
-'Blue Whale'.indexOf('', 11);     // retorna 10
-</pre>
-
-<h3 id="Case-sensitivity">Case-sensitivity</h3>
-
-<p>O método <code>indexOf()</code> é sensível a maiúsculas e minúsculas. Por exemplo, a seguinte expressão retorna -1:</p>
-
-<pre class="brush: js">'Blue Whale'.indexOf('blue'); // retorna -1
-</pre>
-
-<h3 id="Verificando_ocorrências">Verificando ocorrências</h3>
-
-<p>Repara que '0' não é avaliado como <code>true</code> e '-1' não é avaliado como <code>false</code>. Sendo assim, a forma correta de verificar se uma string específica existe dentro de outra string deverá ser:</p>
-
-<pre class="brush: js">'Blue Whale'.indexOf('Blue') !== -1; // true
-'Blue Whale'.indexOf('Bloe') !== -1; // false
-</pre>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Usando_indexOf()_e_lastIndexOf()">Usando <code>indexOf()</code> e <code>lastIndexOf()</code></h3>
-
-<p>O seguinte exemplo usa <code>indexOf()</code> e {{jsxref("String.prototype.lastIndexOf()", "lastIndexOf()")}} para localizar valores na string <code>"Brave new world"</code>.</p>
-
-<pre class="brush: js">var anyString = 'Brave new world';
-
-console.log('O índice do primeiro w desde o início é ' + anyString.indexOf('w'));
-// imprime 8
-console.log('O índice do primeiro w desde o fim é ' + anyString.lastIndexOf('w'));
-// imprime 10
-
-console.log('O índice de "new" desde o início é ' + anyString.indexOf('new'));
-// imprime 6
-console.log('O índice de "new" desde o fim é ' + anyString.lastIndexOf('new'));
-// imprime 6
-</pre>
-
-<h3 id="indexOf()_e_sensibilidade_a_maiúsculas_e_minúsculas"><code>indexOf()</code> e sensibilidade a maiúsculas e minúsculas</h3>
-
-<p>O seguinte exemplo define duas variáveis do tipo string. As variáveis contêm a mesma string exceto o facto da segunda string conter as todas as letras maiúsculas. O primeiro método {{domxref("console.log()")}} apresenta 19. Mas porque o método <code>indexOf()</code> é sensível a maiúsculas e minúsculas, a string <code>"cheddar"</code> não é encontrada em <code>myCapString</code>, logo o segundo método <code>console.log()</code> apresenta -1.</p>
-
-<pre class="brush: js">var myString    = 'brie, pepper jack, cheddar';
-var myCapString = 'Brie, Pepper Jack, Cheddar';
-
-console.log('myString.indexOf("cheddar") é ' + myString.indexOf('cheddar'));
-// imprime 19
-console.log('myCapString.indexOf("cheddar") é ' + myCapString.indexOf('cheddar'));
-// imprime -1
-</pre>
-
-<h3 id="Usando_indexOf()_para_contar_as_ocorrências_de_uma_letra_numa_string">Usando <code>indexOf()</code> para contar as ocorrências de uma letra numa string</h3>
-
-<p>O seguinte exemplo atribuí à variável <code>count</code> o número de ocorrências da letra 'e' na string <code>str</code>:</p>
-
-<pre class="brush: js">var str = 'To be, or not to be, that is the question.';
-var count = 0;
-var pos = str.indexOf('e');
-
-while (pos !== -1) {
-  count++;
-  pos = str.indexOf('e', pos + 1);
-}
-
-console.log(count); // imprime 4
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Definição inicial.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.7', 'String.prototype.indexOf')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.indexof', 'String.prototype.indexOf')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.charAt()")}}</li>
- <li>{{jsxref("String.prototype.lastIndexOf()")}}</li>
- <li>{{jsxref("String.prototype.split()")}}</li>
- <li>{{jsxref("Array.prototype.indexOf()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/string/length/index.html b/files/pt-pt/web/javascript/reference/global_objects/string/length/index.html
deleted file mode 100644
index 7774170252..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/string/length/index.html
+++ /dev/null
@@ -1,125 +0,0 @@
----
-title: String.length
-slug: Web/JavaScript/Reference/Global_Objects/String/length
-tags:
-  - JavaScript
-  - Property
-  - Prototype
-  - Reference
-  - String
-translation_of: Web/JavaScript/Reference/Global_Objects/String/length
----
-<div>{{JSRef}}</div>
-
-<p>A propriedade <strong><code>length</code></strong> representa o comprimento de uma string.</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><var>str</var>.length</code></pre>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>Esta propriedade retorna o número de code units na string. {{interwiki("wikipedia", "UTF-16")}}, o formato usado pelo JavaScript para a string, usa um single 16-bit code unit para representar os caracteres mais comuns, mas necessita de usar two code units para os caracteres menos comuns, pelo que é possível que o valor retornado por <code>length</code> não seja igual ao número de caracteres numa string.</p>
-
-<p>Para uma string vazia, <code>length</code> is 0.</p>
-
-<p>A propriedade estática (static) <code>String.length</code> retorna o valor 1.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Uso_simples">Uso simples</h3>
-
-<pre class="brush: js">var x = 'Mozilla';
-var empty = '';
-
-console.log('Mozilla tem de tamanho ' + x.length + ' code units');
-/* "Mozilla tem de tamanho 7 code units" */
-
-console.log('Uma string vazia tem tamanho ' + empty.length);
-/* "Uma string vazia tem tamanho 0" */
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES1')}}</td>
-   <td>{{Spec2('ES1')}}</td>
-   <td>Definição inicial. Implementado em JavaScript 1.0.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.5.1', 'String.prototype.length')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-properties-of-string-instances-length', 'String.prototype.length')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_dos_browsers">Compatibilidade dos browsers</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Funcionalidade</th>
-   <th>Android</th>
-   <th>Chrome para Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li><a href="http://developer.teradata.com/blog/jasonstrimpel/2011/11/javascript-string-length-and-internationalizing-web-applications">JavaScript <code>String.length</code> and Internationalizing Web Applications</a></li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/string/trim/index.html b/files/pt-pt/web/javascript/reference/global_objects/string/trim/index.html
deleted file mode 100644
index 8ef29112f8..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/string/trim/index.html
+++ /dev/null
@@ -1,139 +0,0 @@
----
-title: String.prototype.trim()
-slug: Web/JavaScript/Reference/Global_Objects/String/Trim
-tags:
-  - ECMAScript 5
-  - JavaScript
-  - Prototipo
-  - Referencia
-  - String
-  - metodo
-translation_of: Web/JavaScript/Reference/Global_Objects/String/Trim
----
-<div>{{JSRef}}</div>
-
-<p>O método <strong><code>trim()</code></strong> elimina espaço em branco de ambos os extremos dum <em>string</em>. Espaço em branco neste contexto são todos os caracteres que apenas representam espaço (espaço, tabulação, espaço fixo, etc.) e todos os caracteres que representam limites de linha (LF, CR, etc.).</p>
-
-<h2 id="Sintaxe">Sintaxe</h2>
-
-<pre class="syntaxbox"><code><var>str</var>.trim()</code></pre>
-
-<h3 id="Valor_devolvido">Valor devolvido</h3>
-
-<p>Um novo <em>string</em> que representa o <em>string</em> que chamou despojado do espaço em branco de ambos os extremos.</p>
-
-<h2 id="Descrição">Descrição</h2>
-
-<p>O método <code>trim()</code> devolve o <em>string</em> despojado do espaço em branco de ambos os extremos. <code>trim()</code> não afecta o valor do <em>string</em> em si.</p>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<h3 id="Using_trim()">Using <code>trim()</code></h3>
-
-<p>O exemplo que se segue mostra o <em>string</em> <code>'foo' em minúsculas</code>:</p>
-
-<pre class="brush: js">var orig = '   foo  ';
-console.log(orig.trim()); // 'foo'
-
-// Outro exemplo de .trim() eliminando espaço em branco de apenas um lado.
-
-var orig = 'foo    ';
-console.log(orig.trim()); // 'foo'
-</pre>
-
-<h2 id="Polyfill">Polyfill</h2>
-
-<p>Ao correr o código que se segue antes de qualquer outro criará <code>trim()</code> se não estiver nativamente disponível.</p>
-
-<pre class="brush: js">if (!String.prototype.trim) {
-  String.prototype.trim = function () {
-    return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
-  };
-}
-</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Especificação</th>
-   <th scope="col">Estado</th>
-   <th scope="col">Comentário</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES5.1', '#sec-15.5.4.20', 'String.prototype.trim')}}</td>
-   <td>{{Spec2('ES5.1')}}</td>
-   <td>Definição inicial. Implementada em JavaScript 1.8.1.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td> </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-string.prototype.trim', 'String.prototype.trim')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_de_navegadores">Compatibilidade de navegadores</h2>
-
-<div>{{CompatibilityTable}}</div>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Característica</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatGeckoDesktop("1.9.1")}}</td>
-   <td>{{CompatIE("9")}}</td>
-   <td>{{CompatOpera("10.5")}}</td>
-   <td>{{CompatSafari("5")}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Característica</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Suporte básico</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-   <td>{{CompatVersionUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Ver_também">Ver também</h2>
-
-<ul>
- <li>{{jsxref("String.prototype.trimLeft()")}} {{non-standard_inline}}</li>
- <li>{{jsxref("String.prototype.trimRight()")}} {{non-standard_inline}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/symbol/hasinstance/index.html b/files/pt-pt/web/javascript/reference/global_objects/symbol/hasinstance/index.html
deleted file mode 100644
index 3ba9666678..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/symbol/hasinstance/index.html
+++ /dev/null
@@ -1,114 +0,0 @@
----
-title: Symbol.hasInstance
-slug: Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance
-tags:
-  - Propriedade
-  - Referencia
-translation_of: Web/JavaScript/Reference/Global_Objects/Symbol/hasInstance
----
-<div>{{JSRef}}</div>
-
-<p>O symbol bem-conhecido <strong><code>Symbol.hasInstance</code></strong> é usado para determinar se um objecto construtor reconhece um objecto como de sua instância. O comportamento do operador {{jsxref("Operators/instanceof", "instanceof")}} pode ser customizado por este symbol.</p>
-
-<div>{{js_property_attributes(0,0,0)}}</div>
-
-<h2 id="Exemplos">Exemplos</h2>
-
-<p>Tu podes implementar o comportamento customizado do seu <code>instanceof</code> deste jeito; por exemplo:</p>
-
-<pre class="brush: js">class MyArray {
-  static [Symbol.hasInstance](instance) {
-    return this.prototype.isPrototypeOf(instance) ||
-           Array.isArray(instance);
-  }
-}
-
-console.log([] instanceof MyArray); // true
-console.log(new MyArray instanceof MyArray); // true
-console.log(new Image instanceof MyArray); // false
-
-class MySubArray extends MyArray {}
-console.log(new MySubArray instanceof MySubArray); // true
-console.log(new MySubArray instanceof MyArray); // true
-console.log(new MyArray instanceof MySubArray); // false</pre>
-
-<h2 id="Especificações">Especificações</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-symbol.hasinstance', 'Symbol.hasInstance')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Initial definition.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-symbol.hasinstance', 'Symbol.hasInstance')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilidade_com_os_navegadores">Compatibilidade com os navegadores</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatChrome(51)}}</td>
-   <td>{{ CompatGeckoDesktop(50) }}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{ CompatGeckoMobile(50) }}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="Veja_também">Veja também</h2>
-
-<ul>
- <li>{{jsxref("Operators/instanceof", "instanceof")}}</li>
- <li>{{jsxref("Global_Objects/Object/isPrototypeOf", "isPrototypeOf()")}}</li>
-</ul>
diff --git a/files/pt-pt/web/javascript/reference/global_objects/symbol/index.html b/files/pt-pt/web/javascript/reference/global_objects/symbol/index.html
deleted file mode 100644
index 00148cd9b1..0000000000
--- a/files/pt-pt/web/javascript/reference/global_objects/symbol/index.html
+++ /dev/null
@@ -1,458 +0,0 @@
----
-title: Symbol
-slug: Web/JavaScript/Reference/Global_Objects/Symbol
-tags:
-  - ECMAScript6
-  - JavaScript
-  - NeedsTranslation
-  - Symbol
-  - TopicStub
-translation_of: Web/JavaScript/Reference/Global_Objects/Symbol
----
-<div>{{JSRef}}</div>
-
-<p>A <strong>symbol</strong> is a unique and immutable data type. It may be used as an identifier for object properties. The <em>Symbol object</em> is an implicit object wrapper for the symbol {{Glossary("Primitive", "primitive data type")}}.</p>
-
-<h2 id="Syntax">Syntax</h2>
-
-<pre class="syntaxbox">Symbol(<em>[description]</em>)</pre>
-
-<h3 id="Parameters">Parameters</h3>
-
-<dl>
- <dt><code>description</code> {{optional_inline}}</dt>
- <dd>Optional, string. A description of the symbol which can be used for debugging but not to access the symbol itself.</dd>
-</dl>
-
-<h2 id="Description">Description</h2>
-
-<p>To create a new primitive symbol, you write <code>Symbol()</code> with an optional string as its description:</p>
-
-<pre class="brush: js">var sym1 = Symbol();
-var sym2 = Symbol("foo");
-var sym3 = Symbol("foo");
-</pre>
-
-<p>The above code creates three new symbols. Note that <code>Symbol("foo")</code> does not coerce the string "foo" into a symbol. It creates a new symbol each time:</p>
-
-<pre class="brush: js">Symbol("foo") === Symbol("foo"); // false</pre>
-
-<p>The following syntax with the {{jsxref("Operators/new", "new")}} operator will throw a {{jsxref("TypeError")}}:</p>
-
-<pre class="brush: js">var sym = new Symbol(); // TypeError</pre>
-
-<p>This prevents authors from creating an explicit <code>Symbol</code> wrapper object instead of a new symbol value and might be surprising as creating explicit wrapper objects around primitive data types is generally possible (for example, <code>new Boolean</code>, <code>new String</code> and <code>new Number</code>).</p>
-
-<p>If you really want to create a <code>Symbol</code> wrapper object, you can use the <code>Object()</code> function:</p>
-
-<pre class="brush: js">var sym = Symbol("foo");
-typeof sym;     // "symbol"
-var symObj = Object(sym);
-typeof symObj;  // "object"
-</pre>
-
-<h3 id="Shared_symbols_in_the_global_symbol_registry">Shared symbols in the global symbol registry</h3>
-
-<p>The above syntax using the <code>Symbol()</code> function will not create a global symbol that is available in your whole codebase. To create symbols available across files and even across realms (each of which has its own global scope), use the methods {{jsxref("Symbol.for()")}} and {{jsxref("Symbol.keyFor()")}} to set and retrieve symbols from the global symbol registry.</p>
-
-<h3 id="Finding_symbol_properties_on_objects">Finding symbol properties on objects</h3>
-
-<p>The method {{jsxref("Object.getOwnPropertySymbols()")}} returns an array of symbols and lets you find symbol properties on a given object. Note that every object is initialized with no own symbol properties, so that this array will be empty unless you've set symbol properties on the object.</p>
-
-<h2 id="Properties">Properties</h2>
-
-<dl>
- <dt><code>Symbol.length</code></dt>
- <dd>Length property whose value is 0.</dd>
- <dt>{{jsxref("Symbol.prototype")}}</dt>
- <dd>Represents the prototype for the <code>Symbol</code> constructor.</dd>
-</dl>
-
-<h3 id="Well-known_symbols">Well-known symbols</h3>
-
-<p>In addition to your own symbols, JavaScript has some built-in symbols which represent internal language behaviors which were not exposed to developers in ECMAScript 5 and before. These symbols can be accessed using the following properties:</p>
-
-<h4 id="Iteration_symbols">Iteration symbols</h4>
-
-<dl>
- <dt>{{jsxref("Symbol.iterator")}}</dt>
- <dd>A method returning the default iterator for an object. Used by <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>.</dd>
-</dl>
-
-<h4 id="Regular_expression_symbols">Regular expression symbols</h4>
-
-<dl>
- <dt>{{jsxref("Symbol.match")}}</dt>
- <dd>A method that matches against a string, also used to determine if an object may be used as a regular expression. Used by {{jsxref("String.prototype.match()")}}.</dd>
- <dt>{{jsxref("Symbol.replace")}}</dt>
- <dd>A method that replaces matched substrings of a string. Used by {{jsxref("String.prototype.replace()")}}.</dd>
- <dt>{{jsxref("Symbol.search")}}</dt>
- <dd>A method that returns the index within a string that matches the regular expression. Used by {{jsxref("String.prototype.search()")}}.</dd>
- <dt>{{jsxref("Symbol.split")}}</dt>
- <dd>A method that splits a string at the indices that match a regular expression. Used by {{jsxref("String.prototype.split()")}}.</dd>
-</dl>
-
-<h4 id="Other_symbols">Other symbols</h4>
-
-<dl>
- <dt>{{jsxref("Symbol.hasInstance")}}</dt>
- <dd>A method determining if a constructor object recognizes an object as its instance. Used by {{jsxref("Operators/instanceof", "instanceof")}}.</dd>
- <dt>{{jsxref("Symbol.isConcatSpreadable")}}</dt>
- <dd>A Boolean value indicating if an object should be flattened to its array elements. Used by {{jsxref("Array.prototype.concat()")}}.</dd>
- <dt>{{jsxref("Symbol.unscopables")}}</dt>
- <dd>An object value of whose own and inherited property names are excluded from the <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> environment bindings of the associated object.</dd>
- <dt>{{jsxref("Symbol.species")}}</dt>
- <dd>A constructor function that is used to create derived objects.</dd>
- <dt>{{jsxref("Symbol.toPrimitive")}}</dt>
- <dd>A method converting an object to a primitive value.</dd>
- <dt>{{jsxref("Symbol.toStringTag")}}</dt>
- <dd>A string value used for the default description of an object. Used by {{jsxref("Object.prototype.toString()")}}.</dd>
-</dl>
-
-<h2 id="Methods">Methods</h2>
-
-<dl>
- <dt>{{jsxref("Symbol.for()", "Symbol.for(key)")}}</dt>
- <dd>Searches for existing symbols with the given key and returns it if found. Otherwise a new symbol gets created in the global symbol registry with this key.</dd>
- <dt>{{jsxref("Symbol.keyFor", "Symbol.keyFor(sym)")}}</dt>
- <dd>Retrieves a shared symbol key from the global symbol registry for the given symbol.</dd>
-</dl>
-
-<h2 id="Symbol_prototype"><code>Symbol</code> prototype</h2>
-
-<p>All Symbols inherit from {{jsxref("Symbol.prototype")}}.</p>
-
-<h3 id="Properties_2">Properties</h3>
-
-<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Properties')}}</p>
-
-<h3 id="Methods_2">Methods</h3>
-
-<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Methods')}}</p>
-
-<h2 id="Examples">Examples</h2>
-
-<h3 id="Using_the_typeof_operator_with_symbols">Using the <code>typeof</code> operator with symbols</h3>
-
-<p>The {{jsxref("Operators/typeof", "typeof")}} operator can help you to identify symbols.</p>
-
-<pre class="brush: js">typeof Symbol() === 'symbol'
-typeof Symbol('foo') === 'symbol'
-typeof Symbol.iterator === 'symbol'
-</pre>
-
-<h3 id="Symbol_type_conversions">Symbol type conversions</h3>
-
-<p>Some things to note when working with type conversion of symbols.</p>
-
-<ul>
- <li>When trying to convert a symbol to a number, a {{jsxref("TypeError")}} will be thrown<br>
-  (e.g. <code>+sym</code> or <code>sym | 0</code>).</li>
- <li>When using loose equality, <code>Object(sym) == sym</code> returns <code>true.</code></li>
- <li><code>Symbol("foo") + "bar" </code>throws a {{jsxref("TypeError")}} (can't convert symbol to string). This prevents you from silently creating a new string property name from a symbol, for example.</li>
- <li>The <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#String_conversion">"safer" <code>String(sym)</code> conversion</a> works like a call to {{jsxref("Symbol.prototype.toString()")}} with symbols, but note that <code>new String(sym)</code> will throw.</li>
-</ul>
-
-<h3 id="Symbols_and_for...in_iteration">Symbols and <code>for...in</code> iteration</h3>
-
-<p>Symbols are not enumerable in <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a> iterations. In addition, {{jsxref("Object.getOwnPropertyNames()")}} will not return symbol object properties, however, you can use {{jsxref("Object.getOwnPropertySymbols()")}} to get these.</p>
-
-<pre class="brush: js">var obj = {};
-
-obj[Symbol("a")] = "a";
-obj[Symbol.for("b")] = "b";
-obj["c"] = "c";
-obj.d = "d";
-
-for (var i in obj) {
-   console.log(i); // logs "c" and "d"
-}</pre>
-
-<h3 id="Symbols_and_JSON.stringify()">Symbols and <code>JSON.stringify()</code></h3>
-
-<p>Symbol-keyed properties will be completely ignored when using <code>JSON.stringify()</code>:</p>
-
-<pre class="brush: js">JSON.stringify({[Symbol("foo")]: "foo"});
-// '{}'</pre>
-
-<p>For more details, see {{jsxref("JSON.stringify()")}}.</p>
-
-<h3 id="Symbol_wrapper_objects_as_property_keys">Symbol wrapper objects as property keys</h3>
-
-<p>When a Symbol wrapper object is used as a property key, this object will be coerced to its wrapped symbol:</p>
-
-<pre class="brush: js">var sym = Symbol("foo");
-var obj = {[sym]: 1};
-obj[sym];            // 1
-obj[Object(sym)];    // still 1
-</pre>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-symbol-objects', 'Symbol')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Initial definition</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-symbol-objects', 'Symbol')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatChrome(38)}}</td>
-   <td>{{CompatGeckoDesktop(36)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>25</td>
-   <td>9</td>
-  </tr>
-  <tr>
-   <td>Symbol.iterator (@@iterator)</td>
-   <td>{{CompatChrome(38)}}</td>
-   <td>{{CompatGeckoDesktop(36)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>25</td>
-   <td>9</td>
-  </tr>
-  <tr>
-   <td>Symbol.unscopables (@@unscopables)</td>
-   <td>{{CompatChrome(38)}}</td>
-   <td>{{CompatGeckoDesktop(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>25</td>
-   <td>9</td>
-  </tr>
-  <tr>
-   <td>Symbol.match (@@match)</td>
-   <td>{{CompatChrome(50)}}</td>
-   <td>{{CompatGeckoDesktop(40)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.species (@@species)</td>
-   <td>{{CompatChrome(51)}}</td>
-   <td>{{CompatGeckoDesktop(41)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.toPrimitive (@@toPrimitive)</td>
-   <td>{{CompatChrome(48)}}</td>
-   <td>{{CompatGeckoDesktop(44)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.replace (@@replace)</td>
-   <td>{{CompatChrome(50)}}</td>
-   <td>{{CompatGeckoDesktop(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.search (@@search)</td>
-   <td>{{CompatChrome(50)}}</td>
-   <td>{{CompatGeckoDesktop(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.split (@@split)</td>
-   <td>{{CompatChrome(50)}}</td>
-   <td>{{CompatGeckoDesktop(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.isConcatSpreadable (@@isconcatspreadable)</td>
-   <td>{{CompatChrome(48)}}</td>
-   <td>{{CompatGeckoDesktop(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.hasInstance (@@hasInstance)</td>
-   <td>{{CompatChrome(51)}}</td>
-   <td>{{CompatGeckoDesktop(50)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.toStringTag (@@toStringTag)</td>
-   <td>{{CompatChrome(49)}}</td>
-   <td>{{CompatGeckoDesktop(51)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Chrome for Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatChrome(38)}}</td>
-   <td>{{CompatGeckoMobile(36)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>25</td>
-   <td>9</td>
-  </tr>
-  <tr>
-   <td>Symbol.iterator (@@iterator)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatChrome(38)}}</td>
-   <td>{{CompatGeckoMobile(36)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>25</td>
-   <td>9</td>
-  </tr>
-  <tr>
-   <td>Symbol.unscopables (@@unscopables)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatChrome(38)}}</td>
-   <td>{{CompatGeckoMobile(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>25</td>
-   <td>9</td>
-  </tr>
-  <tr>
-   <td>Symbol.match (@@match)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile(40)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.species (@@species)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile(41)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.toPrimitive (@@toPrimitive)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile(44)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.replace (@@replace)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.search (@@search)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.split (@@split)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.isConcatSpreadable (@@isconcatspreadable)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile(48)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.hasInstance (@@hasInstance)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile(50)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
-  <tr>
-   <td>Symbol.toStringTag (@@toStringTag)</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatGeckoMobile(51)}}</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatUnknown}}</td>
-   <td>{{CompatUnknown}}</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li><a href="/en-US/docs/Glossary/Symbol">Glossary: Symbol data type</a></li>
- <li>{{jsxref("Operators/typeof", "typeof")}}</li>
- <li><a href="/en-US/docs/Web/JavaScript/Data_structures">Data types and data structures</a></li>
- <li><a href="https://hacks.mozilla.org/2015/06/es6-in-depth-symbols/">"ES6 In Depth: Symbols" on hacks.mozilla.org</a></li>
-</ul>
author	Ryan Johnson <rjohnson@mozilla.com>	2021-04-29 16:16:42 -0700
committer	GitHub <noreply@github.com>	2021-04-29 16:16:42 -0700
commit	95aca4b4d8fa62815d4bd412fff1a364f842814a (patch)
tree	5e57661720fe9058d5c7db637e764800b50f9060 /files/pt-pt/web/javascript/reference/global_objects
parent	ee3b1c87e3c8e72ca130943eed260ad642246581 (diff)
download	translated-content-95aca4b4d8fa62815d4bd412fff1a364f842814a.tar.gz translated-content-95aca4b4d8fa62815d4bd412fff1a364f842814a.tar.bz2 translated-content-95aca4b4d8fa62815d4bd412fff1a364f842814a.zip