fix(guide): simplify directory structure

guide/portuguese/javascript/standard-objects/array/array-destructuring/index.md

@@ -0,0 +1,91 @@
+---
+title: Array Destructuring
+localeTitle: Destruturação de Matrizes
+---
+# Destruturação de Matrizes
+
+A desestruturação é uma maneira conveniente de extrair vários valores dos dados armazenados em Arrays. Ele pode ser usado em locais que recebem dados (como o lado esquerdo de uma atribuição). Este recurso é introduzido no `ECMAScript 6` .
+
+Como extrair os valores é especificado através de padrões (leia sobre exemplos).
+
+### Atribuição de variável básica
+```
+var names = ['neel', 'meet', 'darshan']; 
+ var [nameOne, nameTwo, nameThree] = names; 
+ console.log(nameOne); // "neel" 
+ console.log(nameTwo); // "meet" 
+ console.log(nameThree); // "darshan" 
+```
+
+### Atribuição separada da declaração
+
+Uma variável pode ser atribuída a seu valor através de desestruturação separada da declaração da variável.
+```
+var a, b; 
+ 
+ [a, b] = [1, 2]; 
+ console.log(a); // 1 
+ console.log(b); // 2 
+```
+
+### Valores padrão
+
+Uma variável pode receber um padrão, caso o valor descompactado da matriz seja `undefined` .
+```
+var a, b; 
+ 
+ [a=5, b=7] = [1]; 
+ console.log(a); // 1 
+ console.log(b); // 7 
+```
+
+### Analisando uma matriz retornada de uma função
+
+Sempre foi possível retornar um array de uma função. A desestruturação pode tornar o trabalho com um valor de retorno de matriz mais conciso.
+
+Neste exemplo, `getNames()` retorna os valores `['neel', 'meet']` como sua saída, que pode ser analisada em uma única linha com desestruturação.
+```
+function getNames() { 
+  return ['neel', 'meet']; 
+ } 
+ 
+ var neel, meet; 
+ [nameOne, nameTwo] = getNames(); 
+ console.log(nameOne); // neel 
+ console.log(nameTwo); // meet 
+```
+
+### Ignorando alguns valores retornados
+
+Você pode ignorar os valores de retorno nos quais não está interessado:
+```
+function getNames() { 
+  return ['neel', 'meet', 'darshan']; 
+ } 
+ 
+ var [nameOne, , nameThree] = getNames(); 
+ console.log(nameOne); // neel 
+ console.log(nameThree); // darshan 
+```
+
+Você também pode ignorar todos os valores retornados:
+```
+[,,] = getNames(); 
+```
+
+### Atribuindo o restante de uma matriz a uma variável
+
+Ao desestruturar uma matriz, você pode descompactar e atribuir a parte restante a uma variável usando o padrão restante:
+```
+var [a, ...b] = [1, 2, 3]; 
+ console.log(a); // 1 
+ console.log(b); // [2, 3] 
+```
+
+Observe que um `SyntaxError` será lançado se uma vírgula final for usada no lado esquerdo com um elemento rest:
+```
+var [a, ...b,] = [1, 2, 3]; 
+ // SyntaxError: rest element may not have a trailing comma 
+```
+
+Veja também: **Array Destructuring** | [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Array_destructuring)

guide/portuguese/javascript/standard-objects/array/array-from/index.md

@@ -0,0 +1,19 @@
+---
+title: Array from
+localeTitle: Matriz de
+---
+## Matriz de
+
+O método 'Array.from ()' cria uma nova ocorrência de Array a partir de um objeto semelhante a uma matriz ou iterável.
+
+### Sintaxe:
+
+'' ' Array.from (arrayLike \[, mapFn \[, thisArg\]\]) '' '
+
+### Exemplo:
+
+'' ' Array.from ('foo'); // \["f", "o", "o"\] '' '
+
+#### Mais Informações:
+
+[Documentação MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from)

guide/portuguese/javascript/standard-objects/array/array-isarray/index.md

@@ -0,0 +1,38 @@
+---
+title: Array isArray
+localeTitle: Array isArray
+---
+O método `Array.isArray()` retorna `true` se um objeto for um array, `false` se não for.
+
+## Sintaxe
+```
+Array.isArray(obj) 
+```
+
+### Parâmetros
+
+**obj** O objeto a ser verificado.
+
+[Ligação MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray) | [Link do MSDN](https://msdn.microsoft.com/en-us/LIBRary/ff848265%28v=vs.94%29.aspx)
+
+## Exemplos
+```
+// all following calls return true 
+ Array.isArray([]); 
+ Array.isArray([1]); 
+ Array.isArray(new Array()); 
+ // Little known fact: Array.prototype itself is an array: 
+ Array.isArray(Array.prototype); 
+ 
+ // all following calls return false 
+ Array.isArray(); 
+ Array.isArray({}); 
+ Array.isArray(null); 
+ Array.isArray(undefined); 
+ Array.isArray(17); 
+ Array.isArray('Array'); 
+ Array.isArray(true); 
+ Array.isArray(false); 
+ Array.isArray({ __proto__: Array.prototype }); 
+
+```

guide/portuguese/javascript/standard-objects/array/array-length/index.md

@@ -0,0 +1,26 @@
+---
+title: Array Length
+localeTitle: Comprimento da matriz
+---
+## Comprimento da matriz
+
+`length` é uma propriedade de matrizes em JavaScript que retorna ou define o número de elementos em uma determinada matriz.
+
+A propriedade `length` de um array pode ser retornada assim.
+
+```js
+let desserts = ["Cake", "Pie", "Brownies"]; 
+ console.log(desserts.length); // 3 
+```
+
+O operador de atribuição, em conjunto com a propriedade `length` , pode ser usado para definir o número de elementos em um array como esse.
+
+```js
+let cars = ["Saab", "BMW", "Volvo"]; 
+ cars.length = 2; 
+ console.log(cars.length); // 2 
+```
+
+#### Mais Informações:
+
+https://developer.mozilla.org/pt-BR/docs/Web/JavaScript/Reference/Global\_Objects/Array/length

guide/portuguese/javascript/standard-objects/array/array-of/index.md

@@ -0,0 +1,27 @@
+---
+title: Array of
+localeTitle: Matriz de
+---
+## Matriz de
+
+O método Array.of () cria uma nova ocorrência de Array com um número variável de argumentos, independentemente do número ou tipo dos argumentos.
+
+Sintaxe:
+
+```javascript
+Array.of(element0[, element1[, ...[, elementN]]]) 
+```
+
+## Exemplo
+
+```javascript
+Array.of(7);       // [7] - creates an array with a single element 
+ Array.of(1, 2, 3); // [1, 2, 3] 
+ 
+ Array(7);          // [ , , , , , , ] - creates an empty array with a length property of 7 
+ Array(1, 2, 3);    // [1, 2, 3] 
+```
+
+#### Mais Informações:
+
+Para mais informações, visite [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)

guide/portuguese/javascript/standard-objects/array/array-prototype-concat/index.md

@@ -0,0 +1,45 @@
+---
+title: Array.prototype.concat
+localeTitle: Array.prototype.concat
+---
+## Array.prototype.concat
+
+O método 'concat' retorna um novo array que consiste nos elementos do array em que você o chama, seguidos pelos elementos dos argumentos na ordem em que são passados.
+
+Você pode passar vários argumentos para o método 'concat'. Os argumentos podem ser matrizes ou tipos de dados, como booleanos, cadeias de caracteres e números.
+
+### Sintaxe
+
+```javascript
+const newArray = array.concat(value1, value2, value3...); 
+```
+
+### Exemplos
+
+#### Concatenando duas matrizes
+
+```javascript
+var cold = ['Blue', 'Green', 'Purple']; 
+ var warm = ['Red', 'Orange', 'Yellow']; 
+ 
+ var result = cold.concat(warm); 
+ 
+ console.log(result); 
+ // results in ['Blue', 'Green', 'Purple', 'Red', 'Orange', 'Yellow']; 
+```
+
+#### Concatenando valor para uma matriz
+
+```javascript
+const odd = [1, 3, 5, 7, 9]; 
+ const even = [0, 2, 4, 6, 8]; 
+ 
+ const oddAndEvenAndTen = odd.concat(even, 10); 
+ 
+ console.log(oddAndEvenAndTen); 
+ // results in [1, 3, 5, 7, 9, 0, 2, 4, 6, 8, 10]; 
+```
+
+#### Mais Informações:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat)

guide/portuguese/javascript/standard-objects/array/array-prototype-copywithin/index.md

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.copyWithin
+localeTitle: Array.prototype.copyWithin
+---
+## Array.prototype.copyWithin
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-copywithin/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Mais Informações:

guide/portuguese/javascript/standard-objects/array/array-prototype-entries/index.md

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.entries
+localeTitle: Array.prototype.entries
+---
+## Array.prototype.entries
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-entries/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Mais Informações:

guide/portuguese/javascript/standard-objects/array/array-prototype-every/index.md

@@ -0,0 +1,74 @@
+---
+title: Array.prototype.every
+localeTitle: Array.prototype.every
+---
+O método `every()` testa se todos os elementos da matriz passam no teste implementado pela função fornecida.
+
+**Sintaxe**
+
+```javascript
+  arr.every(callback[, thisArg]) 
+```
+
+## Parâmetros
+
+*   função de **retorno de chamada** para testar cada elemento, considerando três argumentos:
+    
+    *   **currentValue** (obrigatório)
+        
+        O elemento atual sendo processado na matriz.
+        
+    *   **índice** (opcional)
+        
+        O índice do elemento atual sendo processado na matriz.
+        
+    *   **array** (opcional)
+        
+        A matriz cada foi chamada.
+        
+*   **thisArg** Opcional. Valor para usar como este ao executar o retorno de chamada.
+    
+
+[Ligação MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) | [Link do MSDN](https://msdn.microsoft.com/en-us/LIBRary/ff679981%28v=vs.94%29.aspx)
+
+## Descrição
+
+O método `every` chama a função de `callback` uma vez para cada elemento da matriz, em ordem ascendente de índice, até que a função de `callback` retorne false. Se um elemento que faz o `callback` de `callback` retornar false, o método every retornará `false` . Caso contrário, o método every retornará `true` .
+
+A função de retorno de chamada não é chamada para elementos ausentes da matriz.
+
+Além dos objetos de matriz, o método every pode ser usado por qualquer objeto que tenha uma propriedade length e que tenha nomes de propriedades numericamente indexados. `every` não muta a matriz na qual ele é chamado.
+
+## Exemplos
+
+```javascript
+  function isBigEnough(element, index, array) { 
+    return element >= 10; 
+  } 
+  [12, 5, 8, 130, 44].every(isBigEnough);   // false 
+  [12, 54, 18, 130, 44].every(isBigEnough); // true 
+ 
+  // Define the callback function. 
+  function CheckIfEven(value, index, ar) { 
+      document.write(value + " "); 
+ 
+      if (value % 2 == 0) 
+          return true; 
+      else 
+          return false; 
+  } 
+ 
+  // Create an array. 
+  var numbers = [2, 4, 5, 6, 8]; 
+ 
+  // Check whether the callback function returns true for all of the 
+  // array values. 
+  if (numbers.every(CheckIfEven)) 
+      document.write("All are even."); 
+  else 
+      document.write("Some are not even."); 
+ 
+  // Output: 
+  // 2 4 5 Some are not even. 
+
+```

guide/portuguese/javascript/standard-objects/array/array-prototype-fill/index.md

@@ -0,0 +1,26 @@
+---
+title: Array.prototype.fill
+localeTitle: Array.prototype.fill
+---
+## Array.prototype.fill
+
+O método fill () preenche todos os elementos em uma matriz com um valor estático.
+
+Sintaxe:
+
+\`\` \`javascript arr.fill (valor) arr.fill (valor, início) arr.fill (valor, início, fim)
+```
+The fill method takes up to three arguments value, start and end. The start and end arguments are optional with default values of 0 and the length of the this object. 
+ 
+ The fill method is a mutable method, it will change this object itself, and return it, not just return a copy of it. 
+ 
+ ## Examples 
+```
+
+javascript \[1, 2, 3\]. Preenchimento (4); // \[4, 4, 4\] \[1, 2, 3\]. Preenchimento (4, 1); // \[1, 4, 4\]
+
+var fruits = \["Uva", "Pêra", "Maçã", "Morango"\]; fruits.fill ("Watermelon", 2, 4); // Banana, Pêra, Melancia, Melancia \`\` \`
+
+#### Mais Informações:
+
+Para mais informações, visite [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill)

guide/portuguese/javascript/standard-objects/array/array-prototype-filter/index.md

@@ -0,0 +1,78 @@
+---
+title: Array.prototype.filter
+localeTitle: Array.prototype.filter
+---
+## Array.prototype.filter
+
+O método de filtro usa um array como entrada. Leva cada elemento na matriz e aplica uma instrução condicional contra ele. Se esta condição retornar true, o elemento será "empurrado" para a matriz de saída.
+
+Uma vez que cada elemento na matriz de entrada é "filtrado" como tal, gera uma nova matriz contendo cada elemento que retornou verdadeiro.
+
+Neste exemplo abaixo, há uma matriz que possui vários objetos dentro dela. Normalmente, para percorrer esse array, você pode usar um loop for.
+
+Nesse caso, queremos que todos os alunos cujas notas sejam maiores ou iguais a 90.
+
+```javascript
+var students = [ 
+  { name: 'Quincy', grade: 96 }, 
+  { name: 'Jason', grade: 84 }, 
+  { name: 'Alexis', grade: 100 }, 
+  { name: 'Sam', grade: 65 }, 
+  { name: 'Katie', grade: 90 } 
+ ]; 
+ //Define an array to push student objects to. 
+ var studentsGrades = [] 
+ for (var i = 0; i < students.length; i++) { 
+  //Check if grade is greater than 90 
+  if (students[i].grade >= 90) { 
+    //Add a student to the studentsGrades array. 
+    studentsGrades.push(students[i]) 
+  } 
+ } 
+ 
+ return studentsGrades; // [ { name: 'Quincy', grade: 96 }, { name: 'Alexis', grade: 100 }, { name: 'Katie', grade: 90 } ] 
+```
+
+Esse loop funciona, mas é bem demorado. Também pode tornar-se tedioso escrever repetidamente loops para muitos arrays que você precisa percorrer.
+
+Este é um ótimo caso de uso para filtro!
+
+Aqui está o mesmo exemplo usando o filtro:
+
+```javascript
+var students = [ 
+  { name: 'Quincy', grade: 96 }, 
+  { name: 'Jason', grade: 84 }, 
+  { name: 'Alexis', grade: 100 }, 
+  { name: 'Sam', grade: 65 }, 
+  { name: 'Katie', grade: 90 } 
+ ]; 
+ 
+ var studentGrades = students.filter(function (student) { 
+  //This tests if student.grade is greater than or equal to 90. It returns the "student" object if this conditional is met. 
+  return student.grade >= 90; 
+ }); 
+ 
+ return studentGrades; // [ { name: 'Quincy', grade: 96 }, { name: 'Alexis', grade: 100 }, { name: 'Katie', grade: 90 } ] 
+```
+
+O método de filtro é muito mais rápido de escrever e mais limpo de ler enquanto ainda realiza a mesma coisa. Usando a sintaxe do ES6, podemos até replicar o loop for de 6 linhas com filtro:
+
+```javascript
+var students = [ 
+  { name: 'Quincy', grade: 96 }, 
+  { name: 'Jason', grade: 84 }, 
+  { name: 'Alexis', grade: 100 }, 
+  { name: 'Sam', grade: 65 }, 
+  { name: 'Katie', grade: 90 } 
+ ]; 
+ 
+ var studentGrades = students.filter(student => student.grade >= 90); 
+ return studentGrades; // [ { name: 'Quincy', grade: 96 }, { name: 'Alexis', grade: 100 }, { name: 'Katie', grade: 90 } ] 
+```
+
+O filtro é muito útil e é uma excelente opção em loops forçados para filtrar matrizes contra instruções condicionais.
+
+#### Mais Informações:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)

guide/portuguese/javascript/standard-objects/array/array-prototype-find/index.md

@@ -0,0 +1,71 @@
+---
+title: Array.prototype.find
+localeTitle: Array.prototype.find
+---
+## Em formação
+
+O método `find()` retorna o valor do primeiro elemento na matriz que satisfaz a função de teste fornecida. Caso contrário, indefinido é retornado. O método `find()` não altera o array no qual é chamado.
+
+Sintaxe:
+```
+arr.find(callback[, thisArg]) 
+```
+
+##### Parâmetros
+
+*   `callback`
+*   Função para executar em cada valor no array, tomando três argumentos:
+*   `element`
+    *   O elemento atual sendo processado na matriz.
+*   `index`
+    *   O índice do elemento atual sendo processado na matriz.
+*   `array`
+    *   O array encontrado foi chamado.
+*   `thisArg` (opcional)
+*   Objeto para usar como este ao executar o retorno de chamada.
+
+##### Valor de retorno
+
+Um valor na matriz se um elemento passar no teste; caso contrário, indefinido.
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
+
+## Exemplos
+
+Este exemplo encontrará o item correspondente na matriz e retornará o objeto a partir dele.
+
+```javascript
+let items = [ 
+    {name: 'books', quantity: 2}, 
+    {name: 'movies', quantity: 1}, 
+    {name: 'games', quantity: 5} 
+ ]; 
+ 
+ function findMovies(item) { 
+    return item.name === 'movies'; 
+ } 
+ 
+ console.log(items.find(findMovies)); 
+ 
+ // Output 
+ //  { name: 'movies', quantity: 1 } 
+```
+
+O exemplo a seguir mostra a saída de cada parâmetro opcional para a função de retorno de chamada. Isso retornará `undefined` porque nenhum dos itens retornará true da função de retorno de chamada.
+
+```javascript
+function showInfo(element, index, array) { 
+  console.log('element = ' + element + ', index = ' + index + ', array = ' + array); 
+  return false; 
+ } 
+ 
+ console.log('return = ' + [4, 6, 8, 12].find(showInfo)); 
+ 
+ // Output 
+ //  element = 4, index = 0, array = 4,6,8,12 
+ //  element = 6, index = 1, array = 4,6,8,12 
+ //  element = 8, index = 2, array = 4,6,8,12 
+ //  element = 12, index = 3, array = 4,6,8,12 
+ //  return = undefined 
+
+```

guide/portuguese/javascript/standard-objects/array/array-prototype-findindex/index.md

@@ -0,0 +1,73 @@
+---
+title: Array.prototype.findIndex
+localeTitle: Array.prototype.findIndex
+---
+## Em formação
+
+O método `findIndex()` retorna o índice do primeiro elemento na matriz que satisfaz a função de teste fornecida. Caso contrário, -1 é retornado.
+
+O método `findIndex()` não altera o array no qual ele é chamado.
+
+Sintaxe:
+```
+arr.findIndex(callback[, thisArg]) 
+```
+
+##### Parâmetros
+
+*   `callback`
+*   Função para executar em cada valor no array, tomando três argumentos:
+*   `element`
+    *   O elemento atual sendo processado na matriz.
+*   `index`
+    *   O índice do elemento atual sendo processado na matriz.
+*   `array`
+    *   A matriz findIndex () foi chamada.
+*   `thisArg` (opcional)
+*   Objeto para usar como este ao executar o retorno de chamada.
+
+##### Valor de retorno
+
+Um índice na matriz se um elemento passar no teste; caso contrário, -1.
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex)
+
+## Exemplos
+
+Este exemplo encontrará o item correspondente na matriz e retornará o índice a partir dele.
+
+```javascript
+let items = [ 
+    {name: 'books', quantity: 2}, 
+    {name: 'movies', quantity: 1}, 
+    {name: 'games', quantity: 5} 
+ ]; 
+ 
+ function findMovies(item) { 
+    return item.name === 'movies'; 
+ } 
+ 
+ console.log(items.findIndex(findMovies)); 
+ 
+ // Index of 2nd element in the Array is returned, 
+ // so this will result in '1' 
+```
+
+O exemplo a seguir mostra a saída de cada parâmetro opcional para a função de retorno de chamada. Isso retornará `-1` porque nenhum dos itens retornará true da função de retorno de chamada.
+
+```javascript
+function showInfo(element, index, array) { 
+  console.log('element = ' + element + ', index = ' + index + ', array = ' + array); 
+  return false; 
+ } 
+ 
+ console.log('return = ' + [4, 6, 8, 12].findIndex(showInfo)); 
+ 
+ // Output 
+ //  element = 4, index = 0, array = 4,6,8,12 
+ //  element = 6, index = 1, array = 4,6,8,12 
+ //  element = 8, index = 2, array = 4,6,8,12 
+ //  element = 12, index = 3, array = 4,6,8,12 
+ //  return = -1 
+
+```

guide/portuguese/javascript/standard-objects/array/array-prototype-foreach/index.md

@@ -0,0 +1,37 @@
+---
+title: Array.prototype.forEach
+localeTitle: Array.prototype.forEach
+---
+## Array.prototype.forEach
+
+O método array 'forEach' é usado para percorrer cada item de uma matriz. O método é chamado no objeto array e recebe uma função que é chamada em cada item da matriz.
+
+```javascript
+var arr = [1, 2, 3, 4, 5]; 
+ 
+ arr.forEach(number => console.log(number * 2)); 
+ 
+ // 2 
+ // 4 
+ // 6 
+ // 8 
+ // 10 
+```
+
+A função de retorno de chamada também pode ter um segundo parâmetro de um índice, caso você precise referenciar o índice do item atual na matriz.
+
+```javascript
+var arr = [1, 2, 3, 4, 5]; 
+ 
+ arr.forEach((number, i) => console.log(`${number} is at index ${i}`)); 
+ 
+ // '1 is at index 0' 
+ // '2 is at index 1' 
+ // '3 is at index 2' 
+ // '4 is at index 3' 
+ // '5 is at index 4' 
+```
+
+#### Mais Informações:
+
+[Artigo do MDN em Array.prototype.forEach ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)

guide/portuguese/javascript/standard-objects/array/array-prototype-includes/index.md

@@ -0,0 +1,24 @@
+---
+title: Array.prototype.includes
+localeTitle: Array.prototype.includes
+---
+## Array.prototype.includes
+
+O método `includes()` determina se uma matriz inclui um valor. Retorna verdadeiro ou falso.
+
+Leva dois argumentos:
+
+1.  `searchValue` - O elemento a procurar na matriz.
+2.  `fromIndex` - A posição na matriz para começar a procurar o searchValue `searchValue` . Se um valor negativo for fornecido, ele começa a partir do comprimento da matriz menos o valor negativo.
+
+### Exemplo
+
+```js
+const a = [1, 2, 3]; 
+ a.includes(2); // true 
+ a.includes(4); // false 
+```
+
+#### Mais Informações:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes)

guide/portuguese/javascript/standard-objects/array/array-prototype-indexof/index.md

@@ -0,0 +1,44 @@
+---
+title: Array.prototype.indexOf
+localeTitle: Array.prototype.indexOf
+---
+## Array.prototype.indexOf
+
+O método `indexOf()` retorna o primeiro índice no qual um determinado elemento pode ser encontrado na matriz. Se o elemento não estiver presente, retornará -1.
+
+**Sintaxe**
+
+```javascript
+  arr.indexOf(searchElement[, fromIndex]) 
+```
+
+## Parâmetros
+
+*   Elemento **searchElement** para o qual você está procurando
+    
+*   **fromIndex** Opcional. O índice em que você deseja iniciar a pesquisa. Se o fromIndex for maior ou igual ao comprimento da matriz, a matriz não será pesquisada e o método retornará -1. Se o fromIndex for um número negativo, ele considerará um deslocamento do final da matriz (a matriz ainda será pesquisada a partir de lá). O valor padrão é 0, o que significa que toda a matriz é pesquisada.
+    
+
+## Descrição
+
+O método `indexOf` usa cada elemento da matriz na ordem ascendente do índice e o verifica contra `searchElement` usando igualdade estrita ( `===` ). Depois de encontrar um elemento que retorna `true` , ele retorna seu índice.
+
+## Exemplos
+
+```javascript
+var array = [1, 2, 4, 1, 7] 
+ 
+ array.indexOf(1); // 0 
+ array.indexOf(7); // 4 
+ array.indexOf(6); // -1 
+ array.indexOf('1'); // -1 
+ array.indexOf('hello'); // -1 
+ array.indexOf(1, 2); // 3 
+ array.indexOf(1, -3); // 3 
+```
+
+### Mais Informações:
+
+[Ligação MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
+
+[Link do MSDN](https://docs.microsoft.com/en-us/scripting/javascript/reference/indexof-method-array-javascript)

guide/portuguese/javascript/standard-objects/array/array-prototype-join/index.md

@@ -0,0 +1,39 @@
+---
+title: Array.prototype.join
+localeTitle: Array.prototype.join
+---
+O método de array JavaScript `.join()` combinará todos os elementos de um array em uma única string.
+
+**Sintaxe**
+
+```javascript
+  var array = ["Lorem", "Ipsum", "Dolor", "Sit"]; 
+  var str = array.join([separator]); 
+```
+
+## Parâmetros
+
+**separador**
+
+Opcional. Especifica a string a ser usada para separar cada elemento da matriz original. Se o separador não for uma string, ele será convertido em uma string. Se o parâmetro separador não for fornecido, os elementos da matriz serão separados por vírgula por padrão. Se o separador for uma string vazia `""` , todos os elementos da matriz serão unidos sem um caractere separador entre eles.
+
+## Descrição
+
+`.join()` junta todos os elementos de um array em uma única string. Se algum dos elementos da matriz for `undefined` ou `null` , esse elemento será convertido na string vazia `""` .
+
+## Exemplos
+
+**Usando `.join()` quatro maneiras diferentes**
+
+```javascript
+  var array = ["Lorem", "Ipsum", "Dolor" ,"Sit"]; 
+ 
+  var join1 = array.join();           /* assigns "Lorem,Ipsum,Dolor,Sit" to join1 variable 
+                                         (because no separator was provided .join() 
+                                         defaulted to using a comma) */ 
+  var join2 = array.join(", ");       // assigns "Lorem, Ipsum, Dolor, Sit" to join2 variable 
+  var join3 = array.join(" + ");      // assigns "Lorem + Ipsum + Dolor + Sit" to join3 variable 
+  var join4 = array.join("");         // assigns "LoremIpsumDolorSit" to join4 variable 
+```
+
+Fonte: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join)

guide/portuguese/javascript/standard-objects/array/array-prototype-lastindexof/index.md

@@ -0,0 +1,75 @@
+---
+title: Array.prototype.lastIndexOf
+localeTitle: Array.prototype.lastIndexOf
+---
+## Array.prototype.lastIndexof
+
+O método `lastIndexOf()` retorna o último índice no qual um dado elemento pode ser encontrado na matriz, ou -1 se não estiver presente. A matriz é pesquisada de trás para frente, começando em `fromIndex` .
+
+**Sintaxe**
+
+```javascript
+  arr.lastIndexOf(searchElement, fromIndex = arr.length - 1]) 
+```
+
+## Parâmetros
+
+*   **searchElement**
+    
+    *   Elemento para localizar na matriz.
+*   **fromIndex**
+    
+    *   _Opcional_ O índice no qual começar a pesquisar para trás. O padrão é o comprimento da matriz menos um, ou seja, toda a matriz será pesquisada. Se o índice for maior ou igual ao comprimento da matriz, toda a matriz será pesquisada. Se negativo, é considerado como o deslocamento do final da matriz. Observe que, mesmo quando o índice é negativo, a matriz ainda é pesquisada de trás para frente. Se o índice calculado for menor que 0, será retornado -1, ou seja, a matriz não será pesquisada.
+
+[Ligação MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) | [Link do MSDN](https://msdn.microsoft.com/en-us/LIBRary/ff679972%28v=vs.94%29.aspx)
+
+## Retorna
+
+O índice da última ocorrência de `searchElement` na matriz, ou -1, se `searchElement` não for encontrado.
+
+## Descrição
+
+`lastIndexOf` compara `searchElement` a elementos do Array usando igualdade estrita (o mesmo método usado pelo operador ===, ou triple-equals,).
+
+## Observações
+
+A pesquisa ocorre na ordem de índice decrescente (último membro primeiro). Para pesquisar em ordem crescente, use o método `indexOf` .
+
+O argumento opcional `fromIndex` especifica o índice da matriz na qual iniciar a pesquisa. Se `fromIndex` for maior ou igual ao comprimento da matriz, toda a matriz será pesquisada. Se `fromIndex` for negativo, a pesquisa será iniciada no comprimento da matriz e no `fromIndex` . Se o índice calculado for menor que 0, -1 será retornado.
+
+## Exemplos
+
+```javascript
+  var array = [2, 5, 9, 2]; 
+  array.lastIndexOf(2);     // 3 
+  array.lastIndexOf(7);     // -1 
+  array.lastIndexOf(2, 3);  // 3 
+  array.lastIndexOf(2, 2);  // 0 
+  array.lastIndexOf(2, -2); // 0 
+  array.lastIndexOf(2, -1); // 3 
+ 
+  // Create an array. 
+  var ar = ["ab", "cd", "ef", "ab", "cd"]; 
+ 
+  // Determine the first location, in descending order, of "cd". 
+  document.write(ar.lastIndexOf("cd") + "<br/>"); 
+ 
+  // Output: 4 
+ 
+  // Find "cd" in descending order, starting at index 2. 
+  document.write(ar.lastIndexOf("cd", 2) + "<br/>"); 
+ 
+  // Output: 1 
+ 
+  // Search for "gh" (which is not found). 
+  document.write(ar.lastIndexOf("gh")+ "<br/>"); 
+ 
+  // Output: -1 
+ 
+  // Find "ab" with a fromIndex argument of -3. 
+  // The search in descending order starts at index 3, 
+  // which is the array length minus 2. 
+  document.write(ar.lastIndexOf("ab", -3) + "<br/>"); 
+  // Output: 0 
+
+```

guide/portuguese/javascript/standard-objects/array/array-prototype-map/index.md

@@ -0,0 +1,32 @@
+---
+title: Array.prototype.map
+localeTitle: Array.prototype.map
+---
+## Array.prototype.map
+
+O método `.map()` percorre o array especificado e executa a função fornecida em cada elemento. Ele retorna uma nova matriz que contém os resultados da chamada de função em cada elemento.
+
+### Exemplos
+
+**ES5**
+
+```js
+var arr = [1, 2, 3, 4]; 
+ var newArray = arr.map(function(element) { return element * 2}); 
+ console.log(newArray); // [2, 4, 6, 8] 
+```
+
+**ES6**
+
+```js
+const arr = [1, 2, 3, 4]; 
+ const newArray = arr.map(element => element * 2); 
+ console.log(newArray); 
+ //[2, 4, 6, 8] 
+```
+
+**Mais Informações**
+
+Aqui está um screencast interativo Scrimba que explica `Array.prototype.map()` :
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)

guide/portuguese/javascript/standard-objects/array/array-prototype-pop/index.md

@@ -0,0 +1,37 @@
+---
+title: Array.prototype.pop
+localeTitle: Array.prototype.pop
+---
+# Array.prototype.pop
+
+O método `pop()` remove o último elemento e altera o tamanho de uma matriz.
+
+**Sintaxe**
+
+```js
+    arr.pop() 
+```
+
+**Valor de retorno**
+
+*   O elemento removido da matriz; indefinido se a matriz estiver vazia.
+
+## Descrição
+
+O método `pop()` remove o último elemento de uma matriz e retorna esse valor para o chamador.
+
+Se você chamar `pop()` em um array vazio, ele retornará indefinido.
+
+## Exemplos
+
+```js
+let array = [1, 2, 3, 4]; 
+ array.pop(); // removes 4 
+ console.log(array); // [1, 2, 3] 
+ 
+ [].pop() // undefined 
+```
+
+#### Mais Informações:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop)

guide/portuguese/javascript/standard-objects/array/array-prototype-push/index.md

@@ -0,0 +1,52 @@
+---
+title: Array.prototype.push
+localeTitle: Array.prototype.push
+---
+O método `push()` é usado para adicionar um ou mais novos elementos ao final de um array. Também retorna o novo comprimento da matriz.
+
+### Sintaxe
+
+```javascript
+arr.push([element1[, ...[, elementN]]]) 
+```
+
+### Parâmetros
+
+*   **elementN** Os elementos para adicionar ao final da matriz.
+
+### Valor de retorno
+
+O novo comprimento da matriz na qual o método foi chamado.
+
+## Descrição
+
+O método `push()` irá _empurrar_ elementos para o final de um array. Pode levar zero ou mais argumentos. Se nenhum argumento for fornecido, ele simplesmente retornará o comprimento atual da matriz. Se fornecido um ou mais argumentos, ele adicionará esses argumentos ao array na ordem em que estão escritas.
+
+Esse método também retorna o novo comprimento da matriz após o (s) elemento (s) ser (ão) empurrado (s) para ela.
+
+## Exemplo:
+
+```javascript
+var myStarkFamily = ['John', 'Robb', 'Sansa', 'Bran']; 
+```
+
+Suponha que você tenha uma matriz dos filhos da Casa Stark de Game of Thrones. No entanto, um dos membros, **Arya** , está faltando. Sabendo o código acima, você poderia adicioná-lo atribuindo `'Arya'` ao array no índice após o último índice assim:
+
+```javascript
+myStarkFamily[4] = 'Arya'; 
+```
+
+O problema com essa solução é que ela não pode lidar com casos gerais. Se você não sabia de antemão qual é o comprimento do array, você não pode adicionar novos elementos dessa maneira. Isso é o que `push()` é para. Nós não precisamos saber quanto tempo o array é. Nós apenas adicionamos nosso elemento até o final da matriz.
+
+```javascript
+myStarkFamily.push('Arya'); 
+ console.log(myStarkFamily);  // ['John', 'Robb', 'Sansa', 'Bran', 'Arya'] 
+ 
+ var newLength = myStarkFamily.push('Rickon');  // oops! forgot Rickon 
+ console.log(newLength);  // 6 
+ console.log(myStarkFamily);  // ['John', 'Robb', 'Sansa', 'Bran', 'Arya', 'Rickon'] 
+```
+
+#### Mais Informações:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)

guide/portuguese/javascript/standard-objects/array/array-prototype-reduce/index.md

@@ -0,0 +1,67 @@
+---
+title: Array.prototype.reduce
+localeTitle: Array.prototype.reduce
+---
+## Array.prototype.reduce
+
+O método `reduce()` reduz uma matriz de valores para apenas um valor.
+
+O valor único que é retornado pode ser de qualquer tipo.
+
+### Exemplo 1
+
+Transforme uma matriz de inteiros na soma de todos os inteiros na matriz.
+
+```js
+    var numbers = [1,2,3]; 
+    var sum = numbers.reduce(function(total, current){ 
+        return total + current; 
+    }); 
+    console.log(sum); 
+```
+
+Isto irá gerar `6` para o console.
+
+### Descrição
+
+O método `reduce()` tem sido chamado de canivete suíço, ou multi-ferramenta, de métodos de transformação de array. Outros, como `map()` e `filter()` , fornecem transformações mais específicas, enquanto `reduce()` pode ser usado para transformar arrays em qualquer saída desejada.
+
+### Sintaxe
+
+```js
+    arr.reduce(callback[, initialValue]) 
+```
+
+*   O argumento de `callback` é uma função que será chamada uma vez para cada item na matriz. Essa função leva quatro argumentos, mas geralmente apenas os dois primeiros são usados.
+    *   _acumulador_ - o valor retornado da iteração anterior
+    *   _currentValue_ - o item atual na matriz
+    *   _índice_ - o índice do item atual
+    *   _array_ - o array original no qual reduzir foi chamado
+*   O argumento `initialValue` é opcional. Se fornecido, ele será usado como o valor inicial do acumulador na primeira chamada para a função de retorno de chamada (consulte o Exemplo 2 abaixo).
+
+### Exemplo 2
+
+Transforme uma matriz de strings em um único objeto que mostra quantas vezes cada string aparece na matriz. Observe que essa chamada para reduzir passa um objeto vazio `{}` como o parâmetro `initialValue` . Isso será usado como o valor inicial do acumulador (o primeiro argumento) passado para a função de retorno de chamada.
+
+```js
+var pets = ['dog', 'chicken', 'cat', 'dog', 'chicken', 'chicken', 'rabbit']; 
+ 
+ var petCounts = pets.reduce(function(obj, pet){ 
+    if (!obj[pet]) { 
+        obj[pet] = 1; 
+    } else { 
+        obj[pet]++; 
+    } 
+    return obj; 
+ }, {}); 
+ 
+ console.log(petCounts); 
+```
+
+Saída: `js { dog: 2, chicken: 3, cat: 1, rabbit: 1 }`
+
+## Mais Informações:
+
+*   [Como o método Reduce do JavaScript funciona, quando usá-lo e algumas das coisas legais que ele pode fazer](https://medium.freecodecamp.org/reduce-f47a7da511a9)
+*   [Reduzir Avançado](https://www.youtube.com/watch?v=1DMolJ2FrNY)
+*   [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce)

guide/portuguese/javascript/standard-objects/array/array-prototype-reduceright/index.md

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.reduceRight
+localeTitle: Array.prototype.reduceRight
+---
+## Array.prototype.reduceRight
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-reduceright/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Mais Informações:

guide/portuguese/javascript/standard-objects/array/array-prototype-reverse/index.md

@@ -0,0 +1,34 @@
+---
+title: Array.prototype.reverse
+localeTitle: Array.prototype.reverse
+---
+O método de matriz JavaScript `.reverse()` inverterá a ordem dos elementos dentro da matriz.
+
+**Sintaxe**
+
+```javascript
+  var array = [1, 2, 3, 4, 5]; 
+  array.reverse(); 
+```
+
+## Descrição
+
+`.reverse()` inverte o índice dos elementos de um array.
+
+## Exemplos
+
+**Use `.reverse()` para inverter os elementos de um array**
+
+```javascript
+  var array = [1, 2, 3, 4, 5]; 
+  console.log(array); 
+  // Console will output 1, 2, 3, 4, 5 
+ 
+  array.reverse(); 
+ 
+  console.log(array); 
+  /* Console will output 5, 4, 3, 2, 1 and 
+  the variable array now contains the set [5, 4, 3, 2, 1] */ 
+```
+
+Fonte: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)

guide/portuguese/javascript/standard-objects/array/array-prototype-shift/index.md

@@ -0,0 +1,38 @@
+---
+title: Array.prototype.shift
+localeTitle: Array.prototype.shift
+---
+O método de matriz JavaScript `.shift()` removerá o primeiro elemento de uma matriz e retornará esse valor. Isso também irá alterar o comprimento da matriz
+
+**Sintaxe**
+
+```javascript
+  var array = [1, 2, 3, 4]; 
+  array.shift(); 
+```
+
+## Descrição
+
+`.shift()` irá remover o elemento no índice 0 da matriz na qual ele é chamado. Em seguida, ele retorna o valor removido e desloca todos os elementos restantes por 1 valor de índice.
+
+`.shift()` retornará `undefined` se a matriz em que é chamado não contiver elementos.
+
+## Exemplos
+
+**Mudando o primeiro valor de um array**
+
+```javascript
+  var array = [1, 2, 3, 4, 5]; 
+  console.log(array); 
+  // Console will output 1, 2, 3, 4, 5 
+ 
+  array.shift(); 
+  // If we console.log(array.shift()); the console would output 1. 
+ 
+  console.log(array); 
+  /* Console will output 2, 3, 4, 5 and 
+  the variable array now contains the set [2, 3, 4, 5] where 
+  each element has been moved down 1 index value. */ 
+```
+
+Fonte: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift)

guide/portuguese/javascript/standard-objects/array/array-prototype-slice/index.md

@@ -0,0 +1,44 @@
+---
+title: Array.prototype.slice
+localeTitle: Array.prototype.slice
+---
+O método de matriz JavaScript `.slice()` retornará um novo objeto de matriz que será um segmento (uma fatia) da matriz original. O array original não é modificado.
+
+**Sintaxe**
+
+```javascript
+  array.slice() 
+  arr.slice(startIndex) 
+  arr.slice(startIndex, endIndex) 
+```
+
+## Parâmetros
+
+*   **startIndex** O índice baseado em zero onde a fatia deve começar. Se o valor for omitido, começará em 0.
+    
+*   **endIndex** A fatia terminará **antes** deste índice baseado em zero. Um índice negativo é usado para compensar a partir do final da matriz. Se o valor for omitido, o segmento dividirá o final da matriz.
+    
+
+## Exemplos
+
+```javascript
+  var array = ['books', 'games', 'cup', 'sandwich', 'bag', 'phone', 'cactus'] 
+ 
+  var everything = array.slice() 
+  // everything = ['books', 'games', 'cup', 'sandwich', 'bag', 'phone', 'cactus'] 
+ 
+  var kitchen = array.slice(2, 4) 
+  // kitchen = ['cup', 'sandwich'] 
+ 
+  var random = array.slice(4) 
+  // random = ['bag', 'phone', 'cactus'] 
+ 
+  var noPlants = array.slice(0, -1) 
+  // noPlats = ['books', 'games', 'cup', 'sandwich', 'bag', 'phone'] 
+ 
+  // array will still equal ['books', 'games', 'cup', 'sandwich', 'bag', 'phone', 'cactus'] 
+```
+
+#### Mais Informações:
+
+Fonte: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)

guide/portuguese/javascript/standard-objects/array/array-prototype-some/index.md

@@ -0,0 +1,92 @@
+---
+title: Array.prototype.some
+localeTitle: Array.prototype.some
+---
+O método de matriz JavaScript `.some()` terá uma função de retorno de chamada para testar cada elemento na matriz; uma vez que o callback retorna `true` então `.some()` retornará true imediatamente.
+
+**Sintaxe**
+
+```javascript
+  var arr = [1, 2, 3, 4]; 
+  arr.some(callback[, thisArg]); 
+```
+
+## Função de retorno de chamada
+
+**Sintaxe**
+
+```javascript
+  var isEven = function isEven(currentElement, index, array) { 
+      if(currentElement % 2 === 0) { 
+          return true; 
+      } else { 
+          return false; 
+      } 
+  } 
+```
+
+Veja o wiki sobre [operadores aritméticos](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators) para ver o operador `%` restante
+
+**Tem 3 argumentos**
+
+*   currentElement
+    
+    *   Esta é uma variável que representa o elemento que está sendo passado para o retorno de chamada.
+*   índice
+    
+    *   este é o valor do índice do elemento atual começando em 0
+*   array
+    
+    *   a matriz que `.some()` foi chamada.
+
+A função de retorno de chamada deve implementar um caso de teste.
+
+## thisArg
+
+É um parâmetro opcional e mais informações podem ser encontradas no \[MDN
+
+## Descrição
+
+`.some()` executará a função de retorno de chamada para cada elemento na matriz. Quando o retorno de chamada retornar true, `.some()` retornará `true` . Se o retorno de chamada retornar um [valor falso](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) para _cada_ elemento na matriz, então `.some()` retornará false.
+
+`.some()` não irá alterar / alterar o array que o chamou.
+
+## Exemplos
+
+**Passando uma função para `.some()`**
+
+```javascript
+  var isEven = function isEven(currentElement, index, array) { 
+      if(currentElement % 2 === 0) { 
+          return true; 
+      } else { 
+          return false; 
+      } 
+  } 
+ 
+  var arr1 = [1, 2, 3, 4, 5, 6]; 
+  arr1.some(isEven);  // returns true 
+  var arr2 = [1, 3, 5, 7]; 
+  arr2.some(isEven);  // returns false 
+```
+
+**Função anônima**
+
+```javascript
+  var arr3 = ['Free', 'Code', 'Camp', 'The Amazing']; 
+  arr3.some(function(curr, index, arr) { 
+      if (curr === 'The Amazing') { 
+          return true; 
+      } 
+      }); // returns true 
+ 
+  var arr4 = [1, 2, 14, 5, 17, 9]; 
+  arr4.some(function(curr, index, arr) { 
+      return curr > 20; 
+      });  // returns false 
+ 
+  // ES6 arrows functions 
+  arr4.some((curr) => curr >= 14)  // returns true 
+```
+
+Fonte: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)

guide/portuguese/javascript/standard-objects/array/array-prototype-sort/index.md

@@ -0,0 +1,51 @@
+---
+title: Array.prototype.sort
+localeTitle: Array.prototype.sort
+---
+## Array.prototype.sort
+
+Esse método classifica os elementos de uma matriz e retorna a matriz.
+
+O método `sort()` segue a **ordem ASCII** !
+
+índice | caractere --- | --- 33 |! 34 | " 35 | # 35 36 | $ 37 |%
+
+```js
+var myArray = ['#', '!']; 
+ var sortedArray = myArray.sort();   // ['!', '#'] because in the ASCII table "!" is before "#" 
+ 
+ myArray = ['a', 'c', 'b']; 
+ console.log(myArray.sort()); // ['a', 'b', 'c'] 
+ console.log(myArray) // ['a', 'b', 'c'] 
+ 
+ myArray = ['b', 'a', 'aa']; 
+ console.log(myArray.sort());   // ['a', 'aa', 'b'] 
+ 
+ myArray = [1, 2, 13, 23]; 
+ console.log(myArray.sort());   // [1, 13, 2, 23] numbers are treated like strings! 
+```
+
+# Uso avançado
+
+O método `sort()` também pode aceitar um parâmetro: `array.sort(compareFunction)`
+
+### Por exemplo
+
+```js
+function compare(a, b){ 
+  if (a < b){return -1;} 
+  if (a > b){return 1;} 
+  if (a === b){return 0;} 
+ } 
+ 
+ var myArray = [1, 2, 23, 13]; 
+ console.log(myArray.sort()); // [ 1, 13, 2, 23 ] 
+ console.log(myArray.sort(compare));   // [ 1, 2, 13, 23 ] 
+ 
+ myArray = [3, 4, 1, 2]; 
+ sortedArray = myArray.sort(function(a, b){.....});   // it depends from the compareFunction 
+```
+
+#### Mais Informações:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)

guide/portuguese/javascript/standard-objects/array/array-prototype-splice/index.md

@@ -0,0 +1,74 @@
+---
+title: Array.prototype.splice
+localeTitle: Array.prototype.splice
+---
+## Array.prototype.splice
+
+O método splice é semelhante ao [Array.prototype.slice](https://guide.freecodecamp.org/javascript/standard-objects/array/array-prototype-slice) , mas ao contrário de `slice()` ele transforma o array em que é chamado. Ele também difere porque pode ser usado para adicionar valores a uma matriz e removê-los.
+
+### Parâmetros
+
+`splice()` pode levar um ou mais
+
+#### emenda (início)
+
+Se apenas um parâmetro for incluído, a `splice(start)` removerá todos os elementos da matriz do `start` ao final da matriz.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(2); 
+ // exampleArray is now ['first', 'second']; 
+```
+
+Se o `start` for negativo, contará de trás para frente a partir do final do array.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(-1); 
+ // exampleArray is now ['first', 'second', 'third']; 
+```
+
+#### emenda (iniciar, excluirContagem)
+
+Se um segundo parâmetro for incluído, então `splice(start, deleteCount)` removerá os elementos `deleteCount` da matriz, começando com `start` .
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(1, 2); 
+ // exampleArray is now ['first', 'fourth']; 
+```
+
+#### junção (start, deleteCount, newElement1, newElement2,….)
+
+Se mais de dois parâmetros forem incluídos, os parâmetros adicionais serão novos elementos adicionados à matriz. A localização desses elementos adicionados será iniciada no `start` .
+
+Elementos podem ser adicionados sem remover nenhum elemento passando `0` como o segundo parâmetro.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(1, 0, 'new 1', 'new 2'); 
+ // exampleArray is now ['first', 'new 1', 'new 2', 'second', 'third', 'fourth'] 
+```
+
+Elementos também podem ser substituídos.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(1, 2, 'new second', 'new third'); 
+ // exampleArray is now ['first', 'new second', 'new third', 'fourth'] 
+```
+
+### Valor de retorno
+
+Além de alterar a matriz em que ele é chamado, `splice()` também retorna uma matriz contendo os valores removidos. Esta é uma maneira de cortar um array em dois arrays diferentes.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ let newArray = exampleArray.splice(1, 2); 
+ // exampleArray is now ['first', 'fourth'] 
+ // newArray is ['second', 'third'] 
+```
+
+#### Mais Informações:
+
+[MDN - Array.prototype.slice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)

guide/portuguese/javascript/standard-objects/array/array-prototype-tolocalstring/index.md

@@ -0,0 +1,49 @@
+---
+title: Array.prototype.toLocaleString
+localeTitle: Array.prototype.toLocaleString
+---
+## Array.prototype.toLocaleString
+
+O método `toLocaleString()` retorna uma string representando os elementos de uma matriz. Todos os elementos são convertidos em Strings usando seus métodos toLocaleString. O resultado de chamar esta função destina-se a ser específico do idioma.
+
+##### Sintaxe:
+```
+arr.toLocaleString(); 
+```
+
+##### Parâmetros
+
+*   `locales` (Opcional) - argumento contendo uma string ou uma matriz de tags de idioma [BCP 47 tag de idioma](http://tools.ietf.org/html/rfc5646) .
+*   `options` (Opcional) - objeto com propriedades de configuração
+
+##### Valor de retorno
+
+Uma string representando os elementos da matriz separados por uma String específica de local (como uma vírgula “,”)
+
+## Exemplos
+
+```javascript
+var number = 12345; 
+ var date = new Date(); 
+ var myArray = [number, date, 'foo']; 
+ var myString = myArray.toLocaleString(); 
+ 
+ console.log(myString); 
+ // OUTPUT '12345,10/25/2017, 4:20:02 PM,foo' 
+```
+
+Diferentes saídas podem ser exibidas com base no idioma e no identificador de região (a localidade).
+
+```javascript
+var number = 54321; 
+ var date = new Date(); 
+ var myArray = [number, date, 'foo']; 
+ var myJPString = myArray.toLocaleString('ja-JP'); 
+ 
+ console.log(myJPString); 
+ // OUTPUT '54321,10/26/2017, 5:20:02 PM,foo' 
+```
+
+### Mais Informações:
+
+Fonte: [MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString)

guide/portuguese/javascript/standard-objects/array/array-prototype-tosource/index.md

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.toSource
+localeTitle: Array.prototype.toSource
+---
+## Array.prototype.toSource
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-tosource/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Mais Informações:

guide/portuguese/javascript/standard-objects/array/array-prototype-tostring/index.md

@@ -0,0 +1,25 @@
+---
+title: Array.prototype.toString
+localeTitle: Array.prototype.toString
+---
+O método de array JavaScript `.toString()` é usado para converter uma matriz em uma única string, com cada elemento unido por uma vírgula. Não há parâmetros para o método.
+
+**Sintaxe**
+
+```javascript
+  var arr = [1, 2, 3, 4]; 
+  arr.toString(); 
+```
+
+## Uso
+
+```javascript
+  var str1 = [1, 2, 3, 4, 5].toString();  // str1 = '1,2,3,4,5'; 
+  var str2 = ['1', '2', '3', '4'].toString();  // str2 = '1,2,3,4'; 
+  var str3 = ['Free', 'Code', 'Camp'].toString();  // str3 = 'Free,Code,Camp'; 
+  var str4 = ['phone', '555-6726'].toString();   // str4 = 'phone,555-6726'; 
+  var str5 = ['August', 'September', 'October'].toString();  // str5 = 'August,September,October'; 
+  var str6 = ['Words', 'and', 3, 4].toString();  // str6 = 'Words,and,3,4'; 
+```
+
+Fonte: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString)

guide/portuguese/javascript/standard-objects/array/array-prototype-unshift/index.md

@@ -0,0 +1,34 @@
+---
+title: Array.prototype.unshift
+localeTitle: Array.prototype.unshift
+---
+O método de matriz JavaScript `.unshift()` adiciona um ou mais elementos ao início de uma matriz e retorna o novo comprimento da matriz.
+
+**Sintaxe**
+```
+arr.unshift([element1[, ...[, elementN]]]) 
+```
+
+## Parâmetros
+
+Os elementos para adicionar à frente da matriz.
+
+## Retorna
+
+O novo `length` da matriz na qual o método foi chamado.
+
+## Exemplos
+```
+var array = [1, 2, 3, 4, 5]; 
+ 
+ array.unshift(0); 
+ // If we console.log(array.shift()); the console would output 6. 
+ // array is now [0, 1, 2, 3, 4, 5]; 
+ 
+ array.unshift([-1]); 
+ // array is now [[-1], 0, 1, 2, 3, 4, 5]; 
+```
+
+![:rocket:](//forum.freecodecamp.com/images/emoji/emoji_one/rocket.png?v=2 ":foguete:") [Código de execução](https://repl.it/C2V3)
+
+[MDN de](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift) origem

guide/portuguese/javascript/standard-objects/array/array-prototype-values/index.md

@@ -0,0 +1,38 @@
+---
+title: Array.prototype.values
+localeTitle: Array.prototype.values
+---
+## Array.prototype.values
+
+O método `values` retorna um novo objeto `Array Iterator` que contém os valores para cada índice na matriz.
+
+### Sintaxe
+
+```javascript
+arr.values() 
+```
+
+### Retorna
+
+Um novo objeto ittertator de `array` .
+
+### Exemplo
+
+```javascript
+let friends = ["Rachel", "Monica", "Chandler", "Phoebe", "Joey", "Ross"] 
+ 
+ for (let friend of friends) { 
+  console.log(friend) 
+ } 
+ 
+ // Rachel 
+ // Monica 
+ // Chandler 
+ // Phoebe 
+ // Joey 
+ // Ross 
+```
+
+#### Mais Informações:
+
+[Documentação MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values)

guide/portuguese/javascript/standard-objects/array/index.md

@@ -0,0 +1,11 @@
+---
+title: Array
+localeTitle: Matriz
+---
+## Matriz
+
+Este é um esboço. [Ajude nossa comunidade a expandi-lo](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/index.md) .
+
+[Este guia de estilo rápido ajudará a garantir que sua solicitação de recebimento seja aceita](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Mais Informações: