fix(guide): simplify directory structure

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

@@ -0,0 +1,91 @@
+---
+title: Array Destructuring
+localeTitle: Desestructuración de matrices
+---
+# Desestructuración de matrices
+
+La destrucción es una forma conveniente de extraer múltiples valores de los datos almacenados en Arrays. Se puede usar en ubicaciones que reciben datos (como el lado izquierdo de una asignación). Esta característica se introduce en `ECMAScript 6` .
+
+La forma de extraer los valores se especifica a través de patrones (lea los ejemplos).
+
+### Asignación básica de variables
+```
+var names = ['neel', 'meet', 'darshan']; 
+ var [nameOne, nameTwo, nameThree] = names; 
+ console.log(nameOne); // "neel" 
+ console.log(nameTwo); // "meet" 
+ console.log(nameThree); // "darshan" 
+```
+
+### Asignación separada de la declaración
+
+A una variable se le puede asignar su valor a través de la desestructuración separada de la declaración de la variable.
+```
+var a, b; 
+ 
+ [a, b] = [1, 2]; 
+ console.log(a); // 1 
+ console.log(b); // 2 
+```
+
+### Valores predeterminados
+
+A una variable se le puede asignar un valor predeterminado, en el caso de que el valor desempaquetado de la matriz `undefined` esté `undefined` .
+```
+var a, b; 
+ 
+ [a=5, b=7] = [1]; 
+ console.log(a); // 1 
+ console.log(b); // 7 
+```
+
+### Analizar una matriz devuelta desde una función
+
+Siempre ha sido posible devolver una matriz desde una función. La destrucción puede hacer que trabajar con un valor de retorno de matriz sea más conciso.
+
+En este ejemplo, `getNames()` devuelve los valores `['neel', 'meet']` como su salida, que se pueden analizar en una sola línea con la desestructuración.
+```
+function getNames() { 
+  return ['neel', 'meet']; 
+ } 
+ 
+ var neel, meet; 
+ [nameOne, nameTwo] = getNames(); 
+ console.log(nameOne); // neel 
+ console.log(nameTwo); // meet 
+```
+
+### Ignorando algunos valores devueltos
+
+Puedes ignorar los valores de retorno que no te interesan:
+```
+function getNames() { 
+  return ['neel', 'meet', 'darshan']; 
+ } 
+ 
+ var [nameOne, , nameThree] = getNames(); 
+ console.log(nameOne); // neel 
+ console.log(nameThree); // darshan 
+```
+
+También puede ignorar todos los valores devueltos:
+```
+[,,] = getNames(); 
+```
+
+### Asignando el resto de una matriz a una variable
+
+Al desestructurar una matriz, puede descomprimir y asignar la parte restante a una variable usando el patrón de descanso:
+```
+var [a, ...b] = [1, 2, 3]; 
+ console.log(a); // 1 
+ console.log(b); // [2, 3] 
+```
+
+Tenga en cuenta que se `SyntaxError` un `SyntaxError` si se usa una coma al final del lado izquierdo con un elemento de descanso:
+```
+var [a, ...b,] = [1, 2, 3]; 
+ // SyntaxError: rest element may not have a trailing comma 
+```
+
+Vea también: **Array Destructurando** | [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#Array_destructuring)

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

@@ -0,0 +1,19 @@
+---
+title: Array from
+localeTitle: Matriz de
+---
+## Matriz de
+
+El método 'Array.from ()' crea una nueva instancia de Array a partir de un objeto similar a un array o iterable.
+
+### Sintaxis:
+
+'' ' Array.from (arrayLike \[, mapFn \[, thisArg\]\]) '' '
+
+### Ejemplo:
+
+'' ' Array.from ('foo'); // \["f", "o", "o"\] '' '
+
+#### Más información:
+
+[Documentación MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/from)

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

@@ -0,0 +1,38 @@
+---
+title: Array isArray
+localeTitle: Array isArray
+---
+El método `Array.isArray()` devuelve `true` si un objeto es una matriz, `false` si no lo es.
+
+## Sintaxis
+```
+Array.isArray(obj) 
+```
+
+### Parámetros
+
+**obj** El objeto a comprobar.
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/isArray) | [Enlace MSDN](https://msdn.microsoft.com/en-us/LIBRary/ff848265%28v=vs.94%29.aspx)
+
+## Ejemplos
+```
+// 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/spanish/javascript/standard-objects/array/array-length/index.md

@@ -0,0 +1,26 @@
+---
+title: Array Length
+localeTitle: Longitud de la matriz
+---
+## Longitud de la matriz
+
+`length` es una propiedad de las matrices en JavaScript que devuelve o establece el número de elementos en una matriz determinada.
+
+La propiedad de `length` de una matriz se puede devolver como tal.
+
+```js
+let desserts = ["Cake", "Pie", "Brownies"]; 
+ console.log(desserts.length); // 3 
+```
+
+El operador de asignación, junto con la propiedad `length` , se puede usar para establecer el número de elementos en una matriz como tal.
+
+```js
+let cars = ["Saab", "BMW", "Volvo"]; 
+ cars.length = 2; 
+ console.log(cars.length); // 2 
+```
+
+#### Más información:
+
+https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global\_Objects/Array/length

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

@@ -0,0 +1,27 @@
+---
+title: Array of
+localeTitle: Gama de
+---
+## Gama de
+
+El método Array.of () crea una nueva instancia de Array con un número variable de argumentos, independientemente del número o tipo de los argumentos.
+
+Sintaxis:
+
+```javascript
+Array.of(element0[, element1[, ...[, elementN]]]) 
+```
+
+## Ejemplo
+
+```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] 
+```
+
+#### Más información:
+
+Para más información visite [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/of)

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

@@ -0,0 +1,45 @@
+---
+title: Array.prototype.concat
+localeTitle: Array.prototype.concat
+---
+## Array.prototype.concat
+
+El método 'concat' devuelve una nueva matriz que consta de los elementos de la matriz en la que se llama, seguido de los elementos de los argumentos en el orden en que se pasan.
+
+Puede pasar varios argumentos al método 'concat'. Los argumentos pueden ser matrices, o tipos de datos como booleanos, cadenas y números.
+
+### Sintaxis
+
+```javascript
+const newArray = array.concat(value1, value2, value3...); 
+```
+
+### Ejemplos
+
+#### Concatenando dos matrices
+
+```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 a una 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]; 
+```
+
+#### Más información:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/concat)

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

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.copyWithin
+localeTitle: Array.prototype.copyWithin
+---
+## Array.prototype.copyWithin
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-copywithin/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

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

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.entries
+localeTitle: Array.prototype.entries
+---
+## Array.prototype.entries
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-entries/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

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

@@ -0,0 +1,74 @@
+---
+title: Array.prototype.every
+localeTitle: Array.prototype.every
+---
+El método `every()` comprueba si todos los elementos de la matriz pasan la prueba implementada por la función proporcionada.
+
+**Sintaxis**
+
+```javascript
+  arr.every(callback[, thisArg]) 
+```
+
+## Parámetros
+
+*   Función de **devolución de llamada** para probar cada elemento, tomando tres argumentos:
+    
+    *   **valor actual** (requerido)
+        
+        El elemento actual que se está procesando en la matriz.
+        
+    *   **índice** (opcional)
+        
+        El índice del elemento actual que se está procesando en la matriz.
+        
+    *   **array** (opcional)
+        
+        La matriz a la que todos fueron llamados.
+        
+*   **thisArg** Opcional. Valor para utilizar como este al ejecutar la devolución de llamada.
+    
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every) | [Enlace MSDN](https://msdn.microsoft.com/en-us/LIBRary/ff679981%28v=vs.94%29.aspx)
+
+## Descripción
+
+`every` método llama a la función de `callback` una vez para cada elemento de la matriz, en orden de índice ascendente, hasta que la función de `callback` devuelve falso. Si se encuentra un elemento que hace que la `callback` de `callback` devuelva falso, cada método devuelve inmediatamente `false` . De lo contrario, todos los métodos devuelven `true` .
+
+La función de devolución de llamada no se llama para los elementos que faltan de la matriz.
+
+Además de los objetos de matriz, todos los métodos pueden ser utilizados por cualquier objeto que tenga una propiedad de longitud y que tenga nombres de propiedades indexadas numéricamente. `every` no muta la matriz en la que se llama.
+
+## Ejemplos
+
+```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/spanish/javascript/standard-objects/array/array-prototype-fill/index.md

@@ -0,0 +1,26 @@
+---
+title: Array.prototype.fill
+localeTitle: Array.prototype.fill
+---
+## Array.prototype.fill
+
+El método fill () llena todos los elementos en una matriz con un valor estático.
+
+Sintaxis:
+
+\`\` \`javascript arr.fill (valor) arr.fill (valor, inicio) arr.fill (valor, inicio, final)
+```
+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\] .fill (4); // \[4, 4, 4\] \[1, 2, 3\] .fill (4, 1); // \[1, 4, 4\]
+
+var fruits = \["Grape", "Pear", "Apple", "Strawberry"\]; fruits.fill ("Sandía", 2, 4); // Plátano, Pera, Sandía, Sandía \`\` \`
+
+#### Más información:
+
+Para más información visite [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/fill)

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

@@ -0,0 +1,78 @@
+---
+title: Array.prototype.filter
+localeTitle: Array.prototype.filter
+---
+## Array.prototype.filter
+
+El método de filtro toma una matriz como entrada. Toma cada elemento de la matriz y aplica una declaración condicional contra él. Si este condicional devuelve verdadero, el elemento se "empuja" a la matriz de salida.
+
+Una vez que cada elemento de la matriz de entrada se "filtra" como tal, genera una nueva matriz que contiene cada elemento que devolvió verdadero.
+
+En este ejemplo a continuación, hay una matriz que tiene varios objetos dentro de ella. Normalmente, para iterar a través de esta matriz, puede usar un bucle for.
+
+En este caso, queremos obtener todos los estudiantes cuyas calificaciones sean mayores o iguales 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 } ] 
+```
+
+Este for loop funciona, pero es bastante largo. También puede volverse tedioso escribir para bucles una y otra vez para muchos arreglos que necesita recorrer.
+
+Este es un gran caso de uso para el filtro!
+
+Aquí está el mismo ejemplo usando 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 } ] 
+```
+
+El método de filtro es mucho más rápido de escribir y más limpio de leer mientras se sigue logrando lo mismo. Usando la sintaxis de ES6 podemos incluso replicar el bucle for de 6 líneas con 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 } ] 
+```
+
+El filtro es muy útil y es una excelente opción para los bucles que filtran matrices contra sentencias condicionales.
+
+#### Más información:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/filter)

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

@@ -0,0 +1,71 @@
+---
+title: Array.prototype.find
+localeTitle: Array.prototype.find
+---
+## Información
+
+El método `find()` devuelve el valor del primer elemento de la matriz que satisface la función de prueba provista. De lo contrario se devuelve undefined. El método `find()` no muta la matriz en la que se llama.
+
+Sintaxis:
+```
+arr.find(callback[, thisArg]) 
+```
+
+##### Parámetros
+
+*   `callback`
+*   Función para ejecutar en cada valor de la matriz, tomando tres argumentos:
+*   `element`
+    *   El elemento actual que se está procesando en la matriz.
+*   `index`
+    *   El índice del elemento actual que se está procesando en la matriz.
+*   `array`
+    *   El conjunto hallazgo fue llamado.
+*   `thisArg` (Opcional)
+*   Objeto para usar como este cuando se ejecuta la devolución de llamada.
+
+##### Valor de retorno
+
+Un valor en la matriz si un elemento pasa la prueba; De lo contrario, indefinido.
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/find)
+
+## Ejemplos
+
+Este ejemplo buscará el elemento correspondiente en la matriz y devolverá el objeto.
+
+```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 } 
+```
+
+El siguiente ejemplo muestra la salida de cada parámetro opcional a la función de devolución de llamada. Esto devolverá `undefined` porque ninguno de los elementos devolverá verdadero desde la función de devolución de llamada.
+
+```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/spanish/javascript/standard-objects/array/array-prototype-findindex/index.md

@@ -0,0 +1,73 @@
+---
+title: Array.prototype.findIndex
+localeTitle: Array.prototype.findIndex
+---
+## Información
+
+El método `findIndex()` devuelve el índice del primer elemento de la matriz que satisface la función de prueba provista. De lo contrario se devuelve -1.
+
+El método `findIndex()` no muta la matriz en la que se llama.
+
+Sintaxis:
+```
+arr.findIndex(callback[, thisArg]) 
+```
+
+##### Parámetros
+
+*   `callback`
+*   Función para ejecutar en cada valor de la matriz, tomando tres argumentos:
+*   `element`
+    *   El elemento actual que se está procesando en la matriz.
+*   `index`
+    *   El índice del elemento actual que se está procesando en la matriz.
+*   `array`
+    *   Se invocó la matriz findIndex ().
+*   `thisArg` (Opcional)
+*   Objeto para usar como este cuando se ejecuta la devolución de llamada.
+
+##### Valor de retorno
+
+Un índice en la matriz si un elemento pasa la prueba; de lo contrario, -1.
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/findIndex)
+
+## Ejemplos
+
+Este ejemplo buscará el elemento correspondiente en la matriz y devolverá el índice.
+
+```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' 
+```
+
+El siguiente ejemplo muestra la salida de cada parámetro opcional a la función de devolución de llamada. Esto devolverá `-1` porque ninguno de los elementos devolverá verdadero desde la función de devolución de llamada.
+
+```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/spanish/javascript/standard-objects/array/array-prototype-foreach/index.md

@@ -0,0 +1,37 @@
+---
+title: Array.prototype.forEach
+localeTitle: Array.prototype.forEach
+---
+## Array.prototype.forEach
+
+El método de matriz 'forEach' se utiliza para iterar a través de cada elemento en una matriz. El método se llama en el objeto de matriz y se pasa una función que se llama en cada elemento de la matriz.
+
+```javascript
+var arr = [1, 2, 3, 4, 5]; 
+ 
+ arr.forEach(number => console.log(number * 2)); 
+ 
+ // 2 
+ // 4 
+ // 6 
+ // 8 
+ // 10 
+```
+
+La función de devolución de llamada también puede tomar un segundo parámetro de un índice en caso de que necesite hacer referencia al índice del elemento actual en la 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' 
+```
+
+#### Más información:
+
+[Artículo de MDN en Array.prototype.forEach ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach)

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

@@ -0,0 +1,24 @@
+---
+title: Array.prototype.includes
+localeTitle: Array.prototype.includes
+---
+## Array.prototype.includes
+
+El método `includes()` determina si una matriz incluye un valor. Devuelve verdadero o falso.
+
+Se necesitan dos argumentos:
+
+1.  `searchValue` - El elemento a buscar en la matriz.
+2.  `fromIndex` : la posición en la matriz para comenzar a buscar el valor de búsqueda `searchValue` . Si se proporciona un valor negativo, comienza desde la longitud de la matriz menos el valor negativo.
+
+### Ejemplo
+
+```js
+const a = [1, 2, 3]; 
+ a.includes(2); // true 
+ a.includes(4); // false 
+```
+
+#### Más información:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/includes)

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

@@ -0,0 +1,44 @@
+---
+title: Array.prototype.indexOf
+localeTitle: Array.prototype.indexOf
+---
+## Array.prototype.indexOf
+
+El método `indexOf()` devuelve el primer índice en el que se puede encontrar un elemento determinado en la matriz. Si el elemento no está presente, devuelve -1.
+
+**Sintaxis**
+
+```javascript
+  arr.indexOf(searchElement[, fromIndex]) 
+```
+
+## Parámetros
+
+*   Elemento **searchElement** que buscas
+    
+*   **fromIndex** Opcional. El índice en el que desea iniciar la búsqueda. Si theIndex es mayor o igual que la longitud de la matriz, no se busca la matriz y el método devuelve -1. Si el fromIndex es un número negativo, se considera un desplazamiento desde el final de la matriz (la matriz todavía se busca hacia adelante desde allí). El valor predeterminado es 0, lo que significa que se busca en toda la matriz.
+    
+
+## Descripción
+
+El método `indexOf` toma cada elemento de la matriz en orden de índice ascendente y lo `searchElement` con `searchElement` utilizando una igualdad estricta ( `===` ). Una vez que encuentra un elemento que devuelve `true` , devuelve su índice.
+
+## Ejemplos
+
+```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 
+```
+
+### Más información:
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf)
+
+[Enlace MSDN](https://docs.microsoft.com/en-us/scripting/javascript/reference/indexof-method-array-javascript)

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

@@ -0,0 +1,39 @@
+---
+title: Array.prototype.join
+localeTitle: Array.prototype.join
+---
+El método de matriz de JavaScript `.join()` combinará todos los elementos de una matriz en una sola cadena.
+
+**Sintaxis**
+
+```javascript
+  var array = ["Lorem", "Ipsum", "Dolor", "Sit"]; 
+  var str = array.join([separator]); 
+```
+
+## Parámetros
+
+**separador**
+
+Opcional. Especifica la cadena a usar para separar cada elemento de la matriz original. Si el separador no es una cadena, se convertirá en una cadena. Si no se proporciona el parámetro separador, los elementos de la matriz se separan con una coma de forma predeterminada. Si el separador es una cadena vacía `""` , todos los elementos de la matriz se unen sin un carácter separador entre ellos.
+
+## Descripción
+
+`.join()` une todos los elementos de una matriz en una sola cadena. Si alguno de los elementos de la matriz `undefined` está `undefined` o es `null` , ese elemento se convierte a la cadena vacía `""` .
+
+## Ejemplos
+
+**Usando `.join()` cuatro maneras 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 
+```
+
+Fuente: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/join)

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

@@ -0,0 +1,75 @@
+---
+title: Array.prototype.lastIndexOf
+localeTitle: Array.prototype.lastIndexOf
+---
+## Array.prototype.lastIndexof
+
+El método `lastIndexOf()` devuelve el último índice en el que se puede encontrar un elemento determinado en la matriz, o -1 si no está presente. La matriz se busca hacia atrás, comenzando en `fromIndex` .
+
+**Sintaxis**
+
+```javascript
+  arr.lastIndexOf(searchElement, fromIndex = arr.length - 1]) 
+```
+
+## Parámetros
+
+*   **searchElement**
+    
+    *   Elemento para ubicar en la matriz.
+*   **desde el índice**
+    
+    *   _Opcional_ El índice en el que comenzar la búsqueda hacia atrás. El valor predeterminado es la longitud de la matriz menos uno, es decir, se buscará en toda la matriz. Si el índice es mayor o igual que la longitud de la matriz, se buscará la matriz completa. Si es negativo, se toma como el desplazamiento desde el final de la matriz. Tenga en cuenta que incluso cuando el índice es negativo, la matriz se sigue buscando desde atrás hacia adelante. Si el índice calculado es menor que 0, se devuelve -1, es decir, no se buscará la matriz.
+
+[Enlace MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/lastIndexOf) | [Enlace MSDN](https://msdn.microsoft.com/en-us/LIBRary/ff679972%28v=vs.94%29.aspx)
+
+## Devoluciones
+
+El índice de la última aparición de `searchElement` en la matriz, o -1 si no se encuentra `searchElement` .
+
+## Descripción
+
+`lastIndexOf` compara `searchElement` con elementos de la matriz utilizando una igualdad estricta (el mismo método utilizado por el operador ===, o triple-igual).
+
+## Observaciones
+
+La búsqueda se realiza en orden de índice descendente (último miembro primero). Para buscar en orden ascendente, use el método `indexOf` .
+
+El argumento `fromIndex` opcional especifica el índice de matriz en el que se inicia la búsqueda. Si `fromIndex` es mayor o igual que la longitud de la matriz, se busca en toda la matriz. Si `fromIndex` es negativo, la búsqueda comienza en la longitud de la matriz más `fromIndex` . Si el índice calculado es menor que 0, se devuelve -1.
+
+## Ejemplos
+
+```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/spanish/javascript/standard-objects/array/array-prototype-map/index.md

@@ -0,0 +1,32 @@
+---
+title: Array.prototype.map
+localeTitle: Array.prototype.map
+---
+## Array.prototype.map
+
+El método `.map()` recorre la matriz dada y ejecuta la función provista en cada elemento. Devuelve una nueva matriz que contiene los resultados de la llamada de función en cada elemento.
+
+### Ejemplos
+
+**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] 
+```
+
+**Más información**
+
+Aquí hay un screencast interactivo de Scrimba que explica `Array.prototype.map()` :
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/map)

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

@@ -0,0 +1,37 @@
+---
+title: Array.prototype.pop
+localeTitle: Array.prototype.pop
+---
+# Array.prototype.pop
+
+El método `pop()` elimina el último elemento y cambia la longitud de una matriz.
+
+**Sintaxis**
+
+```js
+    arr.pop() 
+```
+
+**Valor de retorno**
+
+*   El elemento eliminado de la matriz; indefinido si la matriz está vacía.
+
+## Descripción
+
+El método `pop()` elimina el último elemento de una matriz y devuelve ese valor a la persona que llama.
+
+Si llama a `pop()` en una matriz vacía, devuelve undefined.
+
+## Ejemplos
+
+```js
+let array = [1, 2, 3, 4]; 
+ array.pop(); // removes 4 
+ console.log(array); // [1, 2, 3] 
+ 
+ [].pop() // undefined 
+```
+
+#### Más información:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/pop)

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

@@ -0,0 +1,52 @@
+---
+title: Array.prototype.push
+localeTitle: Array.prototype.push
+---
+El método `push()` se utiliza para agregar uno o más elementos nuevos al final de una matriz. También devuelve la nueva longitud de la matriz.
+
+### Sintaxis
+
+```javascript
+arr.push([element1[, ...[, elementN]]]) 
+```
+
+### Parámetros
+
+*   **elementN** Los elementos para agregar al final de la matriz.
+
+### Valor de retorno
+
+La nueva longitud de la matriz en la que se llamó el método.
+
+## Descripción
+
+El método `push()` _empujará los_ elementos al final de una matriz. Puede tomar cero o más argumentos. Si no se proporcionan argumentos, simplemente devolverá la longitud actual de la matriz. Si se proporciona uno o más argumentos, agregará estos argumentos a la matriz en el orden en que están escritas.
+
+Este método también devuelve la nueva longitud de la matriz después de que los elementos se insertan en ella.
+
+## Ejemplo:
+
+```javascript
+var myStarkFamily = ['John', 'Robb', 'Sansa', 'Bran']; 
+```
+
+Supongamos que tienes una gran variedad de hijos de la Casa Stark de Juego de tronos. Sin embargo, uno de los miembros, **Arya** , está desaparecido. Conociendo el código anterior, puede agregarla asignando `'Arya'` a la matriz en el índice después del último índice, así:
+
+```javascript
+myStarkFamily[4] = 'Arya'; 
+```
+
+El problema con esta solución es que no puede manejar casos generales. Si no sabía de antemano cuál es la longitud de la matriz, No puedes agregar nuevos elementos de esta manera. Esto es para lo que es `push()` . No necesitamos saber cuánto tiempo es la matriz. Solo agregamos Nuestro elemento hasta el final de la 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'] 
+```
+
+#### Más información:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/push)

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

@@ -0,0 +1,67 @@
+---
+title: Array.prototype.reduce
+localeTitle: Array.prototype.reduce
+---
+## Array.prototype.reduce
+
+El método reduce `reduce()` reduce una matriz de valores a un solo valor.
+
+El único valor devuelto puede ser de cualquier tipo.
+
+### Ejemplo 1
+
+Transforme una matriz de enteros en la suma de todos los enteros de la matriz.
+
+```js
+    var numbers = [1,2,3]; 
+    var sum = numbers.reduce(function(total, current){ 
+        return total + current; 
+    }); 
+    console.log(sum); 
+```
+
+Esto dará salida `6` a la consola.
+
+### Descripción
+
+El método `reduce()` se ha denominado la navaja suiza, o herramienta múltiple, de los métodos de transformación de matrices. Otros, como `map()` y `filter()` , proporcionan transformaciones más específicas, mientras que `reduce()` se puede usar para transformar arreglos en cualquier salida que desee.
+
+### Sintaxis
+
+```js
+    arr.reduce(callback[, initialValue]) 
+```
+
+*   El argumento de `callback` es una función que se llamará una vez para cada elemento de la matriz. Esta función toma cuatro argumentos, pero a menudo solo se usan los dos primeros.
+    *   _acumulador_ - el valor devuelto de la iteración anterior
+    *   _currentValue_ - el elemento actual en la matriz
+    *   _índice_ - el índice del elemento actual
+    *   _matriz_ - la matriz original en la que se llama reducir
+*   El argumento `initialValue` es opcional. Si se proporciona, se utilizará como el valor inicial del acumulador en la primera llamada a la función de devolución de llamada (consulte el Ejemplo 2 a continuación).
+
+### Ejemplo 2
+
+Transforme una matriz de cadenas en un solo objeto que muestre cuántas veces aparece cada cadena en la matriz. Observe que esta llamada para reducir pasa un objeto vacío `{}` como el parámetro `initialValue` . Esto se usará como el valor inicial del acumulador (el primer argumento) pasado a la función de devolución de llamada.
+
+```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); 
+```
+
+Salida: `js { dog: 2, chicken: 3, cat: 1, rabbit: 1 }`
+
+## Más información:
+
+*   [Cómo funciona el método de reducción de JavaScript, cuándo usarlo y algunas de las cosas geniales que puede hacer](https://medium.freecodecamp.org/reduce-f47a7da511a9)
+*   [Avanzado Reducir](https://www.youtube.com/watch?v=1DMolJ2FrNY)
+*   [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/Reduce)

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

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.reduceRight
+localeTitle: Array.prototype.reduceRight
+---
+## Array.prototype.reduceRight
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-reduceright/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

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

@@ -0,0 +1,34 @@
+---
+title: Array.prototype.reverse
+localeTitle: Array.prototype.reverse
+---
+El método de matriz de JavaScript `.reverse()` invertirá el orden de los elementos dentro de la matriz.
+
+**Sintaxis**
+
+```javascript
+  var array = [1, 2, 3, 4, 5]; 
+  array.reverse(); 
+```
+
+## Descripción
+
+`.reverse()` invierte el índice de los elementos de una matriz.
+
+## Ejemplos
+
+**Utilice `.reverse()` para invertir los elementos de una matriz**
+
+```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] */ 
+```
+
+Fuente: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/reverse)

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

@@ -0,0 +1,38 @@
+---
+title: Array.prototype.shift
+localeTitle: Array.prototype.shift
+---
+El método de matriz de JavaScript `.shift()` eliminará el primer elemento de una matriz y devolverá ese valor. Esto también cambiará la longitud de la matriz
+
+**Sintaxis**
+
+```javascript
+  var array = [1, 2, 3, 4]; 
+  array.shift(); 
+```
+
+## Descripción
+
+`.shift()` eliminará el elemento en el índice 0 de la matriz sobre la que se llama. A continuación, devuelve el valor eliminado y cambia todos los elementos restantes hacia abajo en 1 valor de índice.
+
+`.shift()` devolverá `undefined` si la matriz a la que se llama no contiene elementos.
+
+## Ejemplos
+
+**Desplazando el primer valor de una matriz**
+
+```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. */ 
+```
+
+Fuente: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/shift)

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

@@ -0,0 +1,44 @@
+---
+title: Array.prototype.slice
+localeTitle: Array.prototype.slice
+---
+El método de matriz de JavaScript `.slice()` devolverá un nuevo objeto de matriz que será un segmento (una porción) de la matriz original. La matriz original no se modifica.
+
+**Sintaxis**
+
+```javascript
+  array.slice() 
+  arr.slice(startIndex) 
+  arr.slice(startIndex, endIndex) 
+```
+
+## Parámetros
+
+*   **startIndex** El índice de base cero donde debe comenzar la división. Si se omite el valor, comenzará en 0.
+    
+*   **endIndex** La **división** terminará **antes de** este índice de base cero. Se utiliza un índice negativo para compensar desde el final de la matriz. Si se omite el valor, el segmento se dividirá hasta el final de la matriz.
+    
+
+## Ejemplos
+
+```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'] 
+```
+
+#### Más información:
+
+Fuente: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/slice)

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

@@ -0,0 +1,92 @@
+---
+title: Array.prototype.some
+localeTitle: Array.prototype.some
+---
+El método de matriz de JavaScript `.some()` tomará una función de devolución de llamada para probar cada elemento de la matriz; una vez que la devolución de llamada devuelve `true` entonces `.some()` devolverá true inmediatamente.
+
+**Sintaxis**
+
+```javascript
+  var arr = [1, 2, 3, 4]; 
+  arr.some(callback[, thisArg]); 
+```
+
+## Función de devolución de llamada
+
+**Sintaxis**
+
+```javascript
+  var isEven = function isEven(currentElement, index, array) { 
+      if(currentElement % 2 === 0) { 
+          return true; 
+      } else { 
+          return false; 
+      } 
+  } 
+```
+
+Consulte wiki sobre [operadores aritméticos](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators) para ver el operador restante `%`
+
+**Tiene 3 argumentos**
+
+*   elemento actual
+    
+    *   esta es una variable que representa el elemento que se pasa a la devolución de llamada.
+*   índice
+    
+    *   este es el valor de índice del elemento actual que comienza en 0
+*   formación
+    
+    *   la matriz que `.some()` estaba activada.
+
+La función de devolución de llamada debe implementar un caso de prueba.
+
+## esteArg
+
+Es un parámetro opcional y se puede encontrar más información en \[MDN
+
+## Descripción
+
+`.some()` ejecutará la función de devolución de llamada para cada elemento de la matriz. Una vez que la devolución de llamada devuelve true, `.some()` devolverá `true` . Si la devolución de llamada devuelve un [valor falso](https://developer.mozilla.org/en-US/docs/Glossary/Falsy) para _cada_ elemento de la matriz, `.some()` devuelve falso.
+
+`.some()` no cambiará / mutará la matriz que lo llamó.
+
+## Ejemplos
+
+**Pasando una función a `.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 
+```
+
+**Función 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 
+```
+
+Fuente: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/some)

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

@@ -0,0 +1,51 @@
+---
+title: Array.prototype.sort
+localeTitle: Array.prototype.sort
+---
+## Array.prototype.sort
+
+Este método ordena los elementos de una matriz en su lugar y devuelve la matriz.
+
+El método `sort()` sigue el **orden ASCII** !
+
+índice | carácter --- | --- 33 |! 34 | " 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 avanzado
+
+El método `sort()` también puede aceptar un parámetro: `array.sort(compareFunction)`
+
+### Por ejemplo
+
+```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 
+```
+
+#### Más información:
+
+[MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/sort)

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

@@ -0,0 +1,74 @@
+---
+title: Array.prototype.splice
+localeTitle: Array.prototype.splice
+---
+## Array.prototype.splice
+
+El método de empalme es similar a [Array.prototype.slice](https://guide.freecodecamp.org/javascript/standard-objects/array/array-prototype-slice) , pero a diferencia de `slice()` muta la matriz a la que se llama. También difiere en que se puede usar para agregar valores a una matriz, así como para eliminarlos.
+
+### Parámetros
+
+`splice()` puede tomar uno o más
+
+#### empalme (inicio)
+
+Si solo se incluye un parámetro, entonces `splice(start)` eliminará todos los elementos de la matriz desde el `start` hasta el final de la matriz.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(2); 
+ // exampleArray is now ['first', 'second']; 
+```
+
+Si el `start` es negativo, contará hacia atrás desde el final de la matriz.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(-1); 
+ // exampleArray is now ['first', 'second', 'third']; 
+```
+
+#### empalme (inicio, deleteCount)
+
+Si se incluye un segundo parámetro, entonces `splice(start, deleteCount)` eliminará los elementos `deleteCount` de la matriz, comenzando con el `start` .
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ exampleArray.splice(1, 2); 
+ // exampleArray is now ['first', 'fourth']; 
+```
+
+#### empalme (inicio, deleteCount, newElement1, newElement2,….)
+
+Si se incluyen más de dos parámetros, los parámetros adicionales serán elementos nuevos que se agregarán a la matriz. La ubicación de estos elementos agregados comenzará al `start` .
+
+Los elementos se pueden agregar sin eliminar ningún elemento pasando `0` como 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'] 
+```
+
+Los elementos también pueden ser reemplazados.
+
+```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
+
+Además de cambiar la matriz en la que se llama, `splice()` también devuelve una matriz que contiene los valores eliminados. Esta es una forma de cortar una matriz en dos matrices diferentes.
+
+```js
+let exampleArray = ['first', 'second', 'third', 'fourth']; 
+ let newArray = exampleArray.splice(1, 2); 
+ // exampleArray is now ['first', 'fourth'] 
+ // newArray is ['second', 'third'] 
+```
+
+#### Más información:
+
+[MDN - Array.prototype.slice ()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice)

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

@@ -0,0 +1,49 @@
+---
+title: Array.prototype.toLocaleString
+localeTitle: Array.prototype.toLocaleString
+---
+## Array.prototype.toLocaleString
+
+El método `toLocaleString()` devuelve una cadena que representa los elementos de una matriz. Todos los elementos se convierten en cadenas utilizando sus métodos toLocaleString. El resultado de llamar a esta función está destinado a ser específico de la localidad.
+
+##### Sintaxis:
+```
+arr.toLocaleString(); 
+```
+
+##### Parámetros
+
+*   `locales` (Opcional): argumento que contiene una cadena o una matriz de etiquetas de idioma [BCP 47 etiqueta de idioma](http://tools.ietf.org/html/rfc5646) .
+*   `options` (opcional) - objeto con propiedades de configuración
+
+##### Valor de retorno
+
+Una cadena que representa los elementos de la matriz separados por una cadena específica del entorno local (como una coma ",")
+
+## Ejemplos
+
+```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' 
+```
+
+Se podrían mostrar diferentes salidas en función del idioma y el identificador de la región (la configuración regional).
+
+```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' 
+```
+
+### Más información:
+
+Fuente: [MDN](https://developer.mozilla.org/es/docs/Web/JavaScript/Reference/Global_Objects/Array/toLocaleString)

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

@@ -0,0 +1,11 @@
+---
+title: Array.prototype.toSource
+localeTitle: Array.prototype.toSource
+---
+## Array.prototype.toSource
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/array-prototype-tosource/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información:

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

@@ -0,0 +1,25 @@
+---
+title: Array.prototype.toString
+localeTitle: Array.prototype.toString
+---
+El método de matriz de JavaScript `.toString()` se utiliza para convertir una matriz en una sola cadena, con cada elemento unido por una coma. No hay parámetros para el método.
+
+**Sintaxis**
+
+```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'; 
+```
+
+Fuente: [MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/toString)

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

@@ -0,0 +1,34 @@
+---
+title: Array.prototype.unshift
+localeTitle: Array.prototype.unshift
+---
+El método de matriz de JavaScript `.unshift()` agrega uno o más elementos al principio de una matriz y devuelve la nueva longitud de la matriz.
+
+**Sintaxis**
+```
+arr.unshift([element1[, ...[, elementN]]]) 
+```
+
+## Parámetros
+
+Los elementos para agregar al frente de la matriz.
+
+## Devoluciones
+
+La nueva `length` de la matriz sobre la que se llamó el método.
+
+## Ejemplos
+```
+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 ":cohete:") [Ejecutar código](https://repl.it/C2V3)
+
+Fuente [MDN](https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/Array/unshift)

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

@@ -0,0 +1,38 @@
+---
+title: Array.prototype.values
+localeTitle: Array.prototype.values
+---
+## Array.prototype.values
+
+El método de `values` devuelve un nuevo objeto `Array Iterator` que contiene los valores para cada índice en la matriz.
+
+### Sintaxis
+
+```javascript
+arr.values() 
+```
+
+### Devoluciones
+
+Un nuevo objeto ittertator `array` .
+
+### Ejemplo
+
+```javascript
+let friends = ["Rachel", "Monica", "Chandler", "Phoebe", "Joey", "Ross"] 
+ 
+ for (let friend of friends) { 
+  console.log(friend) 
+ } 
+ 
+ // Rachel 
+ // Monica 
+ // Chandler 
+ // Phoebe 
+ // Joey 
+ // Ross 
+```
+
+#### Más información:
+
+[Documentación MDN](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/values)

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

@@ -0,0 +1,11 @@
+---
+title: Array
+localeTitle: Formación
+---
+## Formación
+
+Esto es un talón. [Ayuda a nuestra comunidad a expandirla](https://github.com/freecodecamp/guides/tree/master/src/pages/javascript/standard-objects/array/index.md) .
+
+[Esta guía rápida de estilo ayudará a asegurar que su solicitud de extracción sea aceptada](https://github.com/freecodecamp/guides/blob/master/README.md) .
+
+#### Más información: