Metodos para los Arrays en Javascript

Array()

Acepta 1 argumento integer y devuelve un array con esos elementos.

Array(10) // Array(10) [ <10 empty slots> ]
Array() // Array []

.from()

Utilizamos este método para crear un array. Acepta dos argumentos, el primero acepta un array o algún objeto iterable.

Array.from('never') // Array(5) [ "n", "e", "v", "e", "r" ]

El segundo argumento es para la función de .map() (más abajo puedes saber más sobre el .map()), esta es opcional.

Array.from('never', (el, i) => el + i) // Array(5) [ "n0", "e1", "v2", "e3", "r4" ]

.isArray()

Este método acepta 1 argumento y devuelve si es un array.

Array.isArray('') // false
Array.isArray() // false
Array.isArray(42) // false
Array.isArray([]) // true

Ahora, vamos a esos metodos poco conocidos pero que son la parte principal de este artículo.

.at()

Devuelve el elemento del array de la posición dada. Puede utilizar números negativos en lugar de hacer array[array.length-1].

;['a', 'b', 'c', 'd', 'e']
  .at(0) // a
  [('a', 'b', 'c', 'd', 'e')].at(-1) // e
  [('a', 'b', 'c', 'd', 'e')].at(42) // undefined

.concat()

Junta todos los argumentos a un array.

;['hello'].concat('world', 'bye', 'world', [5]) // Array(5) [ "hello", "world", "bye", "world", 5 ]

.copyWithin()

Copia el array dentro de un rango. Acepta 3 argumentos.

;['1', '2', '3', '4', '5', '6']
  .copyWithin(0) // Array(6) [ "1", "2", "3", "4", "5", "6" ]
  [('1', '2', '3', '4', '5', '6')].copyWithin(3, 0) // Array(6) [ "1", "2", "3", "1", "2", "3" ]
  [('1', '2', '3', '4', '5', '6')].copyWithin(3, 0, 4) // Array(6) [ "1", "2", "3", "1", "2", "3" ]

.every()

Acepta una función de evaluación y devuelve un booleano si todos los elementos de la matriz pasan la prueba.

;['gonna', 'give', 'you']
  .every((e) => e.startsWith('g')) // false
  [('apple', 'android', 'aluminium')].every((e) => e.startsWith('a')) // true

.fill()

Rellena el array con un valor dado. Acepta 3 argumentos. El 1º argumento es el valor que necesitamos rellenar. El 2º argumento es el índice inicial. El 3º argumento es el índice final. Los argumentos 2º y 3º pueden ser opcionales.

Array(10).fill(1) // Array(10) [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]
Array(10).fill(1, 5) // Array(10) [ <5 empty slots>, 1, 1, 1, 1, 1 ]
Array(10).fill(1, 2, 4) // Array(10) [ <2 empty slots>, 1, 1, <6 empty slots> ]

.filter()

Acepta una función de evaluación para hacer un loop con cada elemento del array y lo elimina si no cumple la condición.

;['eating', 'sleeping', 'coding', 'playing']
  .filter((element) => element != 'sleeping') // Array(3) [ "eating", "coding", "playing" ]
  [(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)].filter((element) => element % 2) // Array(5) [ 1, 3, 5, 7, 9 ]

.find()

Acepta una función de evaluación y devuelve el elemento que la función de evaluación pasó.

const people = ['John', 'Anna', 'Peter', 'Rick', 'Elon']
const search = (name) => people.find((element) => element.startsWith(name))

search('Jo') // "John"
search('Rick') // "Rick"
search('Ben') // undefined

.findIndex()

Hace lo mismo que .find(). En lugar de devolver el valor, devuelve la posición del elemento en el array.

const people = ['John', 'Anna', 'Peter', 'Rick', 'Elon']
const search = (name) => people.findIndex((element) => element.startsWith(name))

search('Jo') // 0
search('Rick') // 3
search('Ben') // -1

.flat()

Rellena el array hasta una profundidad determinada. La profundidad será 1 si no hay ningún valor.

;[1, [2, [3, [4]]], 5]
  .flat() // Array(4) [ 1, 2, (2) […], 5 ]
  [(1, [2, [3, [4]]], 5)].flat(2) // Array(5) [ 1, 2, 3, (1) […], 5 ]
  [(1, [2, [3, [4]]], 5)].flat(3) // Array(5) [ 1, 2, 3, 4, 5 ]

.forEach()

Acepta un argumento que llamará por cada elemento del array

;['one', 'two', 'three', 'four'].forEach(alert) // Alerts 4 times

.includes()

Devuelve si el array contiene el valor dado. Además, distingue entre mayúsculas y minúsculas.

;['ant', 'bat', 'cat', 'rat', 'man']
  .includes('man') // true
  [('ant', 'bat', 'cat', 'rat', 'man')].includes('Man') // false
  [('ant', 'bat', 'cat', 'rat', 'man')].includes('dog') // false

.indexOf()

Devuelve el menor índice de un elemento del array (si lo encuentra) después de buscar el valor y si no lo encuentra devuelve -1. El segundo argumento especifica la posición para iniciar la búsqueda.

;['ant', 'bat', 'cat', 'rat', 'man']
  .indexOf('man') // 4
  [('ant', 'bat', 'cat', 'rat', 'man')].includes('Man') // -1
  [('ant', 'bat', 'cat', 'rat', 'man')].includes('ant', 2) // -1

.join()

Une todos los elementos del array en una cadena con un separador (si se da).

;['up', 'never', 'gonna', 'let', 'you', 'down'].join` ` //up never gonna let you down

.lastIndexOf()

Hace lo mismo que .indexOf. En lugar de dar el menor index, esto le da el mayor index.

;['a', 'aaa', 'aaa', 'aa', 'a', 'aaa']
  .lastIndexOf('aaa') // 5
  [('a', 'aaa', 'aaa', 'aa', 'a', 'aaa')].lastIndexOf('b') // -1

.map()

Hace un bucle por cada elemento del array y ejecuta la función dada y cambia el valor a la salida de la función.

;['a', 'b', 'c', 'd', 'e', 'f', 'g'].map((e) => e.toUpperCase()) // Array(7) [ "A", "B", "C", "D", "E", "F", "G" ]

.pop()

Elimina el último elemento del array y lo devuelve.

let arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
console.log(arr.pop()) // g
console.log(arr) // ["a","b","c","d","e","f"]

.shift()

Elimina el primer elemento y devuelve ese elemento.

let arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
console.log(arr.pop()) // g
console.log(arr) // ["a","b","c","d","e","f"]

.push()

Introduce el valor dado en el array. A continuación, devuelve la nueva longitud del array.

let arr = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
console.log(arr.shift()) // a
console.log(arr) // ["b","c","d","e","f","g"]

.unshift()

Hace lo mismo que .push pero añade los elementos al primero.

let h = ['hello']
console.log(h.push('world')) // 2
console.log(h) // Array [ "hello", "world" ]

.reduce()

Acepta una función reducer como primer argumento y la ejecuta. El segundo argumento muestra el valor inicial, y es opcional.

Para calcular la suma de un array, podemos hacer esto.

let tot = 0
const array = [1, 2, 3, 4, 5]
array.forEach((e) => (tot += e))
console.log(tot) // 15

No hay problema de hacer eso, pero podemos usar .reduce() para eso.

const tot = [1, 2, 3, 4, 5].reduce((previous, current) => previous + current, 0)

console.log(tot) // 15

.reduceRight()

Igual que .reduce() pero se ejecuta desde el último hasta el principio del array. Si hacemos una prueba rápida, podemos ver esto.

;[1, 2, 3, 4, 5].reduceRight((previous, current) => {
  console.log('current: ', current)
  return previous + current
})

Outputs

current: 4
current: 3
current: 2
current: 1

.reverse()

¡Invierte el array!

;[1, 2, 3, 4, 5].reverse() // Array(5) [ 5, 4, 3, 2, 1 ]

.slice()

Imagina que cortas un array como si cortaras una verdura. Este método hace lo mismo. Acepta 2 argumentos. El índice inicial y el final.

;['head', 'neck', 'body', 'feet']
  .slice() // (same array)

  [
    // WARNING : weird creatures ahead

    ('head', 'neck', 'body', 'feet')
  ].slice(1)
  [
    // Array(3) [ "neck", "body", "feet" ]

    ('head', 'neck', 'body', 'feet')
  ].slice(1, 3)
// Array [ "neck", "body" ]

.some()

Acepta una función que comprueba y devuelve si uno o más elementos del array lo superan.

const ages = [42, 69, 1, 25, 34, 14]
ages.some((age) => age > 60) // true

.sort()

Ordena un array y devuelve el array ordenado. También puede utilizar su propia función de ordenación.

[1, 2, 4, 8, 4, 2, 1, 6, 8, 4, 2, 7, 56, 2, 9, 5, 52, 1].sort()

// Array(18) [ 1, 1, 1, 2, 2, 2, 2, 4, 4, 4, … ]
```

Using your own sorting function

```javascript
let people = [{
    name: "Andrew",
    age: 19
  }, {
    name: "Posandu",
    age: 14
  }, {
    name: "Luke",
    age: 17
  },
  {
    name: "Ben",
    age: 23
  }
]

console.log(people.sort((a, b) => a.age > b.age))

/*
0: Object { name: "Posandu", age: 14 }
1: Object { name: "Luke", age: 17 }
2: Object { name: "Andrew", age: 19 }
3: Object { name: "Ben", age: 23 }
*/
   ```