Metodos para Arrays en Javascript
Tags: javascript, algorithms, spanish
Published: 2023-03-31 16:04:12

Hola devs... en este compacto pero util post encontraras los métodos mas comunes que puedes usar con Arrays en javascript. Los métodos que veremos serán `pop`, `push`, `unshift`, `splice`, `slice`, `reduce`, `sort`, `concat`, `flat`, `filter`, `join`, `map`, `find`, `filter` `includes`, `indexOf`, `some` y `forEach` así que ponte cómodo y empecemos.

## Metodos
Antes de entrar en materia es importarte saber que algunos de estos métodos mutan directamente el array original haciendo que sus valores o propiedades cambien. Por otra parte tenemos los métodos que no mutan o cambian el array original si no que crean un nuevo array a partir del original.
Así que cuando estes viendo un método que tenga la palabra `muta` o `no muta` entre paréntesis ya sabes que significa.

### `pop (muta)`
El método `pop` elimina el último elemento de un array y retorna el elemento eliminado. El método pop() muta el array original, es decir, modifica el array al que se aplica. El método pop() no toma ningún argumento si el array está vacío, pop() devuelve `undefined`, por ejemplo:

``` js
const miArray = [1, 2, 3, 4, 5];
const elementoEliminado = miArray.pop();
console.log(miArray); // [1, 2, 3, 4]
console.log(elementoEliminado); // 5

```
En el ejemplo anterior, pop() elimina el último elemento del array miArray (que es el valor 5) y devuelve ese valor como resultado. El array original fue modificado y ahora su longitud es de 4.

### `push (muta)`
El método push() permite agregar uno o más elementos al final de un array. Este método muta el array original, es decir, modifica el array al que se aplica. El método push() toma uno o más argumentos y retorna la longitud actualizada del array. 

``` js
const miArray = [1, 2, 3];
const nuevaLongitud = miArray.push(4, 5);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(nuevaLongitud); // 5

```
En el ejemplo anterior, push() agrega los valores 4 y 5 al final del array miArray y retorna la nueva longitud del array como resultado.

### `unshift (muta)`
El método unshift() permite agregar uno o más elementos al inicio de un array. El método unshift() muta el array original, es decir, modifica el array al que se aplica. Al igual que el método `push` el método `unshift` toma uno o más argumentos y devuelve la nueva longitud del array. 

```js
const miArray = [3, 4, 5];
const nuevaLongitud = miArray.unshift(1, 2);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(nuevaLongitud); // 5

```
`unshift` agrega los valores 1 y 2 al inicio del array miArray y devuelve la nueva longitud (5) del array como resultado.

### `splice (muta)` 
El método splice() permite agregar, eliminar o reemplazar elementos en un array. El método `splice` muta el array original, es decir, modifica el array al que se aplica.
El método splice() toma tres o más argumentos:

1. El primer argumento especifica la posición del índice en el array desde el cual se va a iniciar la operación.
2. El segundo argumento (opcional) especifica la cantidad de elementos que se eliminarán a partir de la posición del índice.
3. Los argumentos adicionales (opcional) especifican los elementos que se agregarán a partir de la posición del índice.
 

```js
const miArray = [1, 2, 3, 4, 5];
const elementosEliminados = miArray.splice(2, 2);
console.log(miArray); // [1, 2, 5]
console.log(elementosEliminados); // [3, 4]
```
En este ejemplo, `splice` se utiliza para eliminar dos elementos a partir de la posición del índice 2. Como resultado, se eliminan los elementos 3 y 4 del array miArray y se devuelve un array que contiene los elementos eliminados. Nota que el array original ahora tiene 3 elementos lo que indica que fue modificado por el método splice. 

```js
const miArray = [1, 2, 3, 4, 5];
miArray.splice(2, 0, 6, 7);
console.log(miArray); // [1, 2, 6, 7, 3, 4, 5]
```
En este ejemplo `splice` se utiliza para agregar los elementos 6 y 7 a partir de la posición del índice 2. Como resultado, los elementos 6 y 7 se agregan al array miArray y desplazan los elementos siguientes hacia la derecha.

```js
const miArray = [1, 2, 3, 4, 5];
miArray.splice(2, 2, 6, 7);
console.log(miArray); // [1, 2, 6, 7, 5]
```
En el ejemplo anterior, `splice` se utiliza para reemplazar los elementos 3 y 4 a partir de la posición del índice 2 con los elementos 6 y 7. Como resultado, los elementos 3 y 4 se eliminan del array miArray y se agregan los elementos 6 y 7 en su lugar. 

### `slice (no muta)`
El método slice() permite crear una copia de una porción de un array, sin modificar el array original. El método `slice` devuelve una nueva matriz que incluye los elementos seleccionados del array original.

Este método toma dos argumentos opcionales:

1. El primer argumento especifica la posición del índice donde comenzar a copiar elementos. Si este argumento es omitido, slice() copiará desde el inicio del array (índice 0).
2. El segundo argumento especifica la posición del índice donde finalizar la copia de elementos. Si este argumento es omitido, slice() copiará hasta el final del array.

veamos unos cuantos ejemplos 

```js
const miArray = [1, 2, 3, 4, 5];
const copiaArray = miArray.slice();
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(copiaArray); // [1, 2, 3, 4, 5]
```

En el ejemplo anterior, `slice` se utiliza para crear una copia completa del array miArray. Como resultado, se crea una nueva matriz que contiene los mismos elementos que el array original. 

```js
const miArray = [1, 2, 3, 4, 5];
const copiaArray = miArray.slice(1, 4);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(copiaArray); // [2, 3, 4]
```
En este ejemplo, `slice` se utiliza para crear una copia de los elementos entre los índices 1 y 4 del array miArray. Como resultado, se crea una nueva matriz que contiene los elementos 2, 3 y 4.

```js
const miArray = [1, 2, 3, 4, 5];
const copiaArray = miArray.slice(-3);
console.log(miArray); // [1, 2, 3, 4, 5]
console.log(copiaArray); // [3, 4, 5]
```

En el ejemplo anterior, slice() se utiliza para crear una copia de los últimos tres elementos del array miArray. Como resultado, se crea una nueva matriz que contiene los elementos 3, 4 y 5.

### `reduce (no muta)`
El método reduce se utiliza para iterar sobre los elementos de un arreglo y acumular un valor final a través de una función reductora. La función reductora toma dos argumentos: el acumulador y el valor actual del arreglo.

La sintaxis básica de la función reduce es la siguiente:

```js
array.reduce(function(acumulador, valorActual, index, arreglo) {
  // código de la función reductora
}, valorInicial);

```
Los parámetros de la función reductora son los siguientes:

- `acumulador`: el valor acumulado de la iteración anterior, o el valor inicial proporcionado en el segundo argumento de la función reduce.

- `valorActual`: el valor actual del arreglo en la iteración actual.

- `index (opcional)`: el índice del elemento actual en el arreglo.
- `arreglo (opcional)`: el arreglo original que se está reduciendo.

El segundo argumento de la función reduce es el valor inicial del acumulador. Si este argumento no se proporciona, el valor inicial será el primer elemento del arreglo y la iteración comenzará desde el segundo elemento.
La función reductora debe devolver el valor actualizado del acumulador en cada iteración. El valor actualizado del acumulador se utilizará como el acumulador en la siguiente iteración. Cuando se completa la iteración, el valor final del acumulador se devuelve como resultado de la función reduce.
Por ejemplo, podemos utilizar la función reduce para sumar los elementos de un arreglo de números de la siguiente manera:

```js
const numeros = [1, 2, 3, 4, 5];

const suma = numeros.reduce(function(acumulador, valorActual) {
  return acumulador + valorActual;
}, 0);

console.log(suma); // salida: 15

```
En este ejemplo, el valor inicial del acumulador es 0 y la función reductora suma el valor actual del arreglo al acumulador en cada iteración. Al final de la iteración, el valor final del acumulador es 15, que se devuelve como resultado de la función reduce.

La función reduce es muy versátil y se puede utilizar para realizar muchas otras operaciones en los arreglos, como encontrar el valor máximo o mínimo, concatenar elementos de una cadena, crear un objeto a partir de un arreglo, entre otros.

### `sort (muta)`

El método sort() se utiliza para ordenar los elementos de un arreglo en su lugar, es decir, modifica el arreglo original.
Algo importante a tener en cuenta, todos los elementos indefinidos se ordenan al final de la matriz.

La sintaxis básica de la función sort() es la siguiente:

```js
array.sort([comparador])
```
El parámetro opcional comparador es una función callback que se utiliza para especificar el criterio de ordenación. Si no se proporciona ningún argumento, los elementos del arreglo se ordenarán como cadenas de caracteres. Si se proporciona un comparador, se utilizará para comparar los elementos del arreglo y determinar su orden.

La función comparadora toma dos argumentos, que representan dos elementos del arreglo que se están comparando. La función debe devolver un número negativo si el primer elemento es menor que el segundo, un número positivo si el primer elemento es mayor que el segundo, o cero si ambos elementos son iguales.

Por ejemplo, podemos utilizar la función sort() para ordenar un arreglo de números de la siguiente manera:

```js
const numeros = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5];

numeros.sort(function(a, b) {
  return a - b;
});

console.log(numeros); // salida: [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]

```
En este ejemplo, la función comparadora resta el segundo elemento del primero y devuelve el resultado. Esto ordena los elementos del arreglo en orden ascendente.

También podemos utilizar la función sort() para ordenar un arreglo de objetos según una propiedad específica. Por ejemplo:

```js
const personas = [  { nombre: 'Ana', edad: 24 },  { nombre: 'Pedro', edad: 31 },  { nombre: 'Juan', edad: 18 },  { nombre: 'María', edad: 27 },  { nombre: 'Luis', edad: 22 },];

personas.sort(function(a, b) {
  if (a.edad < b.edad) {
    return -1;
  }
  if (a.edad > b.edad) {
    return 1;
  }
  return 0;
});

console.log(personas); // salida: [
                        //   { nombre: 'Juan', edad: 18 },
                        //   { nombre: 'Luis', edad: 22 },
                        //   { nombre: 'Ana', edad: 24 },
                        //   { nombre: 'María', edad: 27 },
                        //   { nombre: 'Pedro', edad: 31 }
                        // ]

```
En este ejemplo, la función comparadora compara los objetos según su propiedad edad y devuelve un número negativo, positivo o cero según el orden correspondiente.

En resumen, el método sort() en JavaScript se utiliza para ordenar los elementos de un arreglo en su lugar. La función comparadora especifica el criterio de ordenación y toma dos elementos como argumentos, y devuelve un número negativo, positivo o cero según el orden correspondiente. Es importante destacar que sort() modifica el arreglo original.

### `concat (no muta)`
El método concat() se utiliza para concatenar uno o más arreglos con el arreglo actual y crear un nuevo arreglo sin modificar los arreglos originales.

La sintaxis básica de la función concat() es la siguiente:

```js
array.concat(valor1, valor2, ..., valorN)

```
Donde valor1, valor2, ..., valorN son uno o más valores o arreglos que se desean concatenar con el arreglo actual.

La función concat() devuelve un nuevo arreglo que contiene los elementos del arreglo actual y los elementos de los arreglos pasados como argumentos en el orden en que se proporcionan. Si uno de los argumentos de concat() es un arreglo, los elementos de ese arreglo se agregan individualmente al nuevo arreglo.

Por ejemplo, podemos utilizar la función concat() para concatenar dos arreglos de la siguiente manera:

```js
const numeros1 = [1, 2, 3];
const numeros2 = [4, 5, 6];
const numerosConcatenados = numeros1.concat(numeros2);

console.log(numerosConcatenados); // salida: [1, 2, 3, 4, 5, 6]

```
En este ejemplo, la función concat() se utiliza para concatenar los arreglos numeros1 y numeros2 en un nuevo arreglo llamado numerosConcatenados.

También podemos utilizar la función concat() para concatenar un valor o varios valores al arreglo actual. Por ejemplo:

```js
const nombres = ['Ana', 'Pedro', 'Juan'];
const nombresConcatenados = nombres.concat('María', 'Luis');

console.log(nombresConcatenados); // salida: ['Ana', 'Pedro', 'Juan', 'María', 'Luis']

```
En este ejemplo, la función concat() se utiliza para concatenar los valores 'María' y 'Luis' al arreglo nombres en un nuevo arreglo llamado nombresConcatenados.

Es importante destacar que la función concat() no modifica los arreglos originales, sino que devuelve un nuevo arreglo que contiene los elementos de los arreglos concatenados. 

**a tener en cuenta:** `concat` copia las referencias de objeto del original en la nueva matriz para que tanto la matriz original como la nueva se refieran al mismo objeto.
Por lo tanto, si se modifica un objeto al que se hace referencia, los cambios son visibles tanto para las matrices nuevas como para las originales.

### `flat (no muta)`
El método flat() se utiliza para "aplanar" un arreglo multidimensional en un arreglo unidimensional.

La sintaxis básica de la función flat() es la siguiente:

```js
array.flat(depth)

```

Donde depth es un número que indica la profundidad máxima a la que se deben aplanar los subarreglos. Si se omite el argumento depth, se asume un valor de 1, lo que significa que se aplanará un solo nivel de subarreglos.

La función flat() devuelve un nuevo arreglo que contiene todos los elementos del arreglo original, pero aplanados en un solo nivel.

Por ejemplo, podemos utilizar la función flat() para aplanar un arreglo multidimensional de la siguiente manera:

```js
const numeros = [1, 2, [3, 4, [5, 6]]];

const numerosAplanados = numeros.flat();

console.log(numerosAplanados); // salida: [1, 2, 3, 4, [5, 6]]

```
En este ejemplo, la función flat() se utiliza para aplanar el arreglo numeros, que contiene tres niveles de subarreglos. El resultado es un nuevo arreglo llamado numerosAplanados que contiene todos los elementos del arreglo original aplanados en un solo nivel.

También podemos utilizar la función flat() con un argumento depth para aplanar subarreglos en diferentes niveles de profundidad. Por ejemplo:

```js
const numeros = [1, 2, [3, 4, [5, 6]]];

const numerosAplanados = numeros.flat(2);

console.log(numerosAplanados); // salida: [1, 2, 3, 4, 5, 6]
```
En este ejemplo, la función flat() se utiliza con un argumento depth de 2 para aplanar el arreglo numeros hasta un máximo de dos niveles de profundidad. El resultado es un nuevo arreglo llamado numerosAplanados que contiene todos los elementos del arreglo original aplanados en un solo nivel.

Es importante destacar que la función flat() no modifica el arreglo original, sino que devuelve un nuevo arreglo que contiene los elementos aplanados. Si uno de los elementos del arreglo original es un objeto, la función flat() no lo modificará, simplemente lo incluirá en el nuevo arreglo aplanado.

### `filter (no muta)`
El método filter() se utiliza para filtrar los elementos de un arreglo según una condición especificada en una función de callback. La función de callback debe devolver un valor booleano que indica si el elemento debe ser incluido en el nuevo arreglo resultante o no.

La sintaxis básica de la función filter() es la siguiente:

```js
array.filter(callback(element[, index[, array]])[, thisArg])

```
Donde callback es la función que se utilizará para filtrar los elementos del arreglo, element es el elemento actual que se está evaluando, index es el índice del elemento actual y array es el arreglo original. El argumento thisArg es opcional y se refiere al valor de this que se utilizará dentro de la función de callback.

La función filter() devuelve un nuevo arreglo que contiene solo los elementos del arreglo original que pasaron la prueba de la función de callback. Es decir, si la función de callback devuelve true, el elemento se incluirá en el nuevo arreglo, y si devuelve false, el elemento se omitirá.

Por ejemplo, podemos utilizar la función filter() para filtrar solo los números pares de un arreglo de la siguiente manera:

```js
const numeros = [1, 2, 3, 4, 5, 6];

const numerosPares = numeros.filter(function(num) {
  return num % 2 === 0;
});

console.log(numerosPares); // salida: [2, 4, 6]

```
En este ejemplo, la función filter() se utiliza para crear un nuevo arreglo llamado numerosPares que contiene solo los números pares del arreglo original numeros. La función de callback utiliza el operador % para comprobar si el número actual es divisible por 2 y, si es así, devuelve true, lo que significa que el número debe ser incluido en el nuevo arreglo.

También podemos utilizar la función filter() con funciones de callback más complejas para filtrar elementos de un arreglo según múltiples criterios. Por ejemplo:

```js
const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 20 }
];

const personasMayores = personas.filter(function(persona) {
  return persona.edad > 25 && persona.nombre.startsWith('M');
});

console.log(personasMayores); // salida: [{ nombre: 'María', edad: 30 }]

```
En este ejemplo, la función filter() se utiliza para crear un nuevo arreglo llamado personasMayores que contiene solo las personas mayores de 25 años cuyo nombre comienza con la letra "M". La función de callback utiliza las propiedades edad y nombre de cada objeto para comprobar si cumple con los criterios especificados.

Es importante destacar que la función filter() no modifica el arreglo original, sino que devuelve un nuevo arreglo que contiene solo los elementos que cumplieron con la condición de la función de callback.

### `join (no muta)`
El método join() se utiliza para concatenar todos los elementos de un arreglo en una sola cadena de texto. El método join() recibe un argumento opcional que especifica el separador que se utilizará para separar cada elemento en la cadena resultante.

La sintaxis básica de la función join() es la siguiente:

```js
array.join([separator])

```
Donde separator es el separador que se utilizará para separar cada elemento en la cadena resultante. Si este argumento no se proporciona, se utilizará una coma (",") como separador por defecto.

El método join() devuelve una cadena que contiene todos los elementos del arreglo separados por el separador especificado.

Por ejemplo, podemos utilizar la función join() para concatenar los elementos de un arreglo en una sola cadena separada por guiones:

```js
const palabras = ['hola', 'mundo', 'feliz', 'día'];
const frase = palabras.join('-');

console.log(frase); // salida: "hola-mundo-feliz-día"

```
En este ejemplo, la función join() se utiliza para concatenar los elementos del arreglo palabras en una sola cadena separada por guiones. El resultado se asigna a la variable frase.

También podemos utilizar la función join() para crear una cadena a partir de un arreglo de objetos. En este caso, debemos proporcionar una función de callback para convertir cada objeto en una cadena antes de concatenarlo con los demás elementos. Por ejemplo:

```js
const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 20 }
];

const lista = personas.map(function(persona) {
  return persona.nombre + ' (' + persona.edad + ' años)';
}).join(', ');

console.log(lista); // salida: "Juan (25 años), María (30 años), Pedro (20 años)"

```
En este ejemplo, la función map() se utiliza para crear un nuevo arreglo que contiene una cadena para cada objeto en el arreglo personas. La función de callback utiliza las propiedades nombre y edad de cada objeto para construir la cadena. Luego, la función join() se utiliza para concatenar todas las cadenas en una sola lista separada por comas.

El método join() no modifica el arreglo original, sino que devuelve una nueva cadena que contiene todos los elementos del arreglo concatenados.

### `map (no muta)`
El método map() se utiliza en los objetos de tipo Array para crear un nuevo arreglo a partir de un arreglo existente. El nuevo arreglo resultante se crea aplicando una función de transformación a cada elemento del arreglo original. En otras palabras, el método map() itera sobre los elementos de un arreglo y devuelve un nuevo arreglo con los resultados de aplicar una función a cada elemento.

La sintaxis básica del método map() es la siguiente:

```js
array.map(function(currentValue, index, arr) {
  // Código que se ejecuta para cada elemento del arreglo
  return newValue;
});

```
Donde array es el arreglo original, currentValue es el valor del elemento actual que se está procesando, index es el índice del elemento actual en el arreglo, y arr es el arreglo original completo. La función de transformación que se pasa como argumento toma como entrada el elemento actual del arreglo y devuelve el resultado de la transformación.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos crear un nuevo arreglo donde cada número se multiplica por dos. Podemos utilizar el método map() para lograr esto de la siguiente manera:

```js
const numeros = [1, 2, 3, 4, 5];
const numerosDobles = numeros.map(function(numero) {
  return numero * 2;
});

console.log(numerosDobles); // salida: [2, 4, 6, 8, 10]

```
En este ejemplo, la función de transformación toma cada número del arreglo original y lo multiplica por dos. El resultado se almacena en un nuevo arreglo llamado numerosDobles.

El método map() también se puede utilizar para transformar un arreglo de objetos. En este caso, la función de transformación debe devolver un objeto con las propiedades transformadas que deseamos incluir en el nuevo arreglo. Por ejemplo, supongamos que tenemos un arreglo de objetos que representan a personas y queremos crear un nuevo arreglo que contenga solo los nombres de estas personas:

```js
const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 20 }
];

const nombres = personas.map(function(persona) {
  return persona.nombre;
});

console.log(nombres); // salida: ['Juan', 'María', 'Pedro']

```
En este ejemplo, la función de transformación devuelve la propiedad nombre de cada objeto en el arreglo original. El resultado se almacena en un nuevo arreglo llamado nombres.

Es importante destacar que el método map() no modifica el arreglo original, sino que devuelve un nuevo arreglo con los resultados de la transformación. El nuevo arreglo tendrá la misma longitud que el arreglo original.

### `find (no muta)`

El método find() en JavaScript es una función que se utiliza en los objetos de tipo Array para buscar un elemento específico dentro del arreglo. El método devuelve el **primer** elemento que cumple con la condición especificada en una función de prueba. Si no se encuentra ningún elemento que cumpla con la condición, el método devuelve undefined.

La sintaxis básica del método find() es la siguiente:

```js
array.find(function(currentValue, index, arr) {
  // Código que se ejecuta para cada elemento del arreglo
  return condition;
});

```

Donde array es el arreglo original, currentValue es el valor del elemento actual que se está procesando, index es el índice del elemento actual en el arreglo, y arr es el arreglo original completo. La función de prueba que se pasa como argumento toma como entrada el elemento actual del arreglo y devuelve un valor booleano que indica si el elemento cumple con la condición de búsqueda.

Por ejemplo, supongamos que tenemos un arreglo de objetos que representan a personas y queremos buscar la primera persona que tenga una edad mayor a 25 años. Podemos utilizar el método find() para lograr esto de la siguiente manera:

```js
const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 20 }
];

const personaMayor25 = personas.find(function(persona) {
  return persona.edad > 25;
});

console.log(personaMayor25); // salida: { nombre: 'María', edad: 30 }

```
En este ejemplo, la función de prueba evalúa si la edad de la persona actual es mayor a 25 años. El método find() devuelve el primer elemento del arreglo que cumple con esta condición, que en este caso es el objeto que representa a María.

El método find() también se puede utilizar para buscar un elemento en un arreglo de valores simples. En este caso, la función de prueba debe evaluar si el valor actual es igual al valor que estamos buscando. Por ejemplo, supongamos que tenemos un arreglo de números y queremos buscar el primer número que sea divisible por 3:

```js
const numeros = [1, 4, 7, 9, 12, 15];

const numeroDivisible3 = numeros.find(function(numero) {
  return numero % 3 === 0;
});

console.log(numeroDivisible3); // salida: 9

```
En este ejemplo, la función de prueba evalúa si el número actual es divisible por 3 utilizando el operador %. El método find() devuelve el primer elemento del arreglo que cumple con esta condición, que en este caso es el número 9.

Es importante destacar que el método find() devuelve solo el primer elemento que cumple con la condición de búsqueda. Si hay varios elementos que cumplen con la condición, solo se devuelve el primero que se encuentre. Si se requiere encontrar todos los elementos que cumplan con la condición, se debe utilizar el método filter().

### `filter (no muta)`
El método filter() se utiliza en los objetos de tipo Array para filtrar elementos que cumplen con una condición especificada y devuelve un nuevo arreglo con los elementos que cumplen con dicha condición. La sintaxis básica del método filter() es la siguiente:

```js
array.filter(function(currentValue, index, arr) {
  // Código que se ejecuta para cada elemento del arreglo
  return condition;
});

```

Donde array es el arreglo original, currentValue es el valor del elemento actual que se está procesando, index es el índice del elemento actual en el arreglo, y arr es el arreglo original completo. La función de prueba que se pasa como argumento toma como entrada el elemento actual del arreglo y devuelve un valor booleano que indica si el elemento cumple con la condición de búsqueda.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos filtrar solo los números que son pares. Podemos utilizar el método filter() para lograr esto de la siguiente manera:

```js
const numeros = [1, 2, 3, 4, 5, 6];

const numerosPares = numeros.filter(function(numero) {
  return numero % 2 === 0;
});

console.log(numerosPares); // salida: [2, 4, 6]

```
En este ejemplo, la función de prueba evalúa si el número actual es par utilizando el operador %. El método filter() devuelve un nuevo arreglo con los elementos del arreglo original que cumplen con esta condición, que en este caso son los números pares.

El método filter() también se puede utilizar para filtrar elementos de un arreglo de objetos. En este caso, la función de prueba debe evaluar si alguna propiedad del objeto cumple con la condición de búsqueda. Por ejemplo, supongamos que tenemos un arreglo de objetos que representan a personas y queremos filtrar solo las personas que son mayores de edad:

```js
const personas = [
  { nombre: 'Juan', edad: 25 },
  { nombre: 'María', edad: 30 },
  { nombre: 'Pedro', edad: 17 }
];

const personasMayoresEdad = personas.filter(function(persona) {
  return persona.edad >= 18;
});

console.log(personasMayoresEdad); // salida: [{ nombre: 'Juan', edad: 25 }, { nombre: 'María', edad: 30 }]

```
En este ejemplo, la función de prueba evalúa si la edad de la persona actual es mayor o igual a 18 años. El método filter() devuelve un nuevo arreglo con los objetos del arreglo original que cumplen con esta condición, que en este caso son las personas mayores de edad.

Es importante destacar que el método filter() devuelve un nuevo arreglo con los elementos que cumplen con la condición de búsqueda. El arreglo original no se modifica. Si se requiere modificar el arreglo original, se debe utilizar el método map().

### `includes (no muta)`
El método includes() en JavaScript es una función que se utiliza en los objetos de tipo Array para determinar si un valor específico se encuentra en el arreglo. La sintaxis básica del método includes() es la siguiente:

```js
array.includes(valueToFind[, fromIndex])

```
Donde array es el arreglo en el que se realizará la búsqueda, valueToFind es el valor que se busca en el arreglo y fromIndex es un índice opcional que indica el índice desde el cual comenzar la búsqueda.

El método includes() devuelve un valor booleano que indica si el valor especificado se encuentra en el arreglo o no. Si el valor se encuentra en el arreglo, se devuelve true; de lo contrario, se devuelve false.

Por ejemplo, supongamos que tenemos un arreglo de nombres y queremos determinar si un nombre específico se encuentra en el arreglo. Podemos utilizar el método includes() para lograr esto de la siguiente manera:

```js
const nombres = ['Juan', 'María', 'Pedro'];

const estaJuan = nombres.includes('Juan');
const estaLuis = nombres.includes('Luis');

console.log(estaJuan); // salida: true
console.log(estaLuis); // salida: false

```
En este ejemplo, el método includes() se utiliza para determinar si el nombre "Juan" se encuentra en el arreglo. El método devuelve true, lo que indica que el nombre se encuentra en el arreglo. Luego, el método se utiliza para determinar si el nombre "Luis" se encuentra en el arreglo. El método devuelve false, lo que indica que el nombre no se encuentra en el arreglo.

También podemos utilizar el segundo argumento opcional fromIndex para indicar el índice desde el cual comenzar la búsqueda. Por ejemplo:

```js
const numeros = [1, 2, 3, 4, 5];

const estaCinco = numeros.includes(5, 3);

console.log(estaCinco); // salida: true

```
En este ejemplo, el método includes() se utiliza para determinar si el valor 5 se encuentra en el arreglo numeros comenzando desde el índice 3. El método devuelve true, lo que indica que el valor se encuentra en el arreglo.

Es importante destacar que el método includes() realiza una búsqueda estricta, es decir, compara los valores utilizando el operador de igualdad estricta (===). Esto significa que los valores deben ser del mismo tipo y tener el mismo valor para que el método devuelva true. Por ejemplo, si buscamos el número 2 en el arreglo ['2'], el método includes() devolverá false, ya que los valores no son del mismo tipo.

### `indexof (no muta)`

El método indexOf() en JavaScript se utiliza para buscar la posición de un elemento especificado dentro de un arreglo. La sintaxis básica del método indexOf() es la siguiente:

```js
array.indexOf(searchElement[, fromIndex])

```
Donde array es el arreglo en el que se realizará la búsqueda, searchElement es el elemento que se busca en el arreglo y fromIndex es un índice opcional que indica el índice desde el cual comenzar la búsqueda.

El método indexOf() devuelve el índice del **primer** elemento que coincida con el valor especificado o -1 si el valor no se encuentra en el arreglo.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos determinar la posición del número 3 dentro del arreglo. Podemos utilizar el método indexOf() para lograr esto de la siguiente manera:

```js
const numeros = [1, 2, 3, 4, 5];

const posicionTres = numeros.indexOf(3);

console.log(posicionTres); // salida: 2

```
En este ejemplo, el método indexOf() se utiliza para determinar la posición del número 3 dentro del arreglo numeros. El método devuelve 2, que es el índice del primer elemento que coincide con el valor especificado.

También podemos utilizar el segundo argumento opcional fromIndex para indicar el índice desde el cual comenzar la búsqueda. Por ejemplo:

```js
const numeros = [1, 2, 3, 4, 5];

const posicionCuatro = numeros.indexOf(4, 2);

console.log(posicionCuatro); // salida: 3

```
En este ejemplo, el método indexOf() se utiliza para determinar la posición del número 4 dentro del arreglo numeros comenzando desde el índice 2. El método devuelve 3, que es el índice del primer elemento que coincide con el valor especificado a partir del índice 2.

Es importante destacar que el método indexOf() devuelve el índice del primer elemento que coincida con el valor especificado. Si hay varios elementos que coinciden con el valor especificado, el método solo devuelve el índice del primer elemento. Si queremos buscar la posición de todos los elementos que coincidan con el valor especificado, podemos utilizar el método filter() en combinación con el método indexOf().

### `some` 
El método some() en JavaScript se utiliza para comprobar si al menos un elemento de un arreglo cumple con una condición determinada. La sintaxis básica del método some() es la siguiente:

```js
array.some(callback[, thisArg])

```
Donde array es el arreglo en el que se realiza la comprobación, callback es una función que se ejecuta en cada elemento del arreglo y thisArg es un valor opcional que se utiliza como this dentro de la función de devolución de llamada.

La función de devolución de llamada (callback) que se pasa como argumento al método some() debe devolver un valor booleano (true o false). La función se ejecuta una vez por cada elemento en el arreglo hasta que un elemento devuelva true. Si la función devuelve true para al menos un elemento del arreglo, el método some() devuelve true, de lo contrario devuelve false.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos comprobar si al menos uno de los elementos es mayor que 10. Podemos utilizar el método some() para lograr esto de la siguiente manera:

```js
const numeros = [1, 2, 15, 4, 5];

const alMenosUnoMayorQueDiez = numeros.some((numero) => {
  return numero > 10;
});

console.log(alMenosUnoMayorQueDiez); // salida: true

```
En este ejemplo, el método some() se utiliza para comprobar si al menos uno de los elementos del arreglo numeros es mayor que 10. La función de devolución de llamada devuelve true para el elemento 15, por lo que el método some() devuelve true.

### `forEach` 

El método forEach() en JavaScript se utiliza para iterar sobre los elementos de un arreglo y ejecutar una función para cada elemento. La sintaxis básica del método forEach() es la siguiente:

```js
array.forEach(callback[, thisArg])

```
Donde array es el arreglo sobre el que se itera, callback es la función que se ejecuta para cada elemento y thisArg es un valor opcional que se utiliza como this dentro de la función de devolución de llamada.

La función de devolución de llamada (callback) que se pasa como argumento al método forEach() se ejecuta una vez para cada elemento del arreglo, en orden. La función puede tener hasta tres argumentos: el valor del elemento actual, el índice del elemento actual y el arreglo sobre el que se está iterando.

La función de devolución de llamada puede realizar cualquier tarea necesaria para cada elemento del arreglo, como actualizar el valor de cada elemento o realizar un cálculo basado en los valores de los elementos. Es importante tener en cuenta que el método forEach() no devuelve ningún valor, simplemente ejecuta la función de devolución de llamada para cada elemento del arreglo.

Por ejemplo, supongamos que tenemos un arreglo de números y queremos imprimir cada número en la consola. Podemos utilizar el método forEach() para lograr esto de la siguiente manera:

```js
const numeros = [1, 2, 3, 4, 5];

numeros.forEach((numero) => {
  console.log(numero);
});

```
En este ejemplo, el método forEach() se utiliza para iterar sobre el arreglo numeros y ejecutar la función de devolución de llamada para cada elemento del arreglo. La función de devolución de llamada simplemente imprime cada número en la consola.