# 10 Array Methods esenciales para tu arsenal

Los arreglos son una estructura de datos fundamental en cualquier lenguaje de programación. En JavaScript, los arreglos son objetos que permiten almacenar una colección de elementos ordenados. Los elementos pueden ser de cualquier tipo, incluyendo números, cadenas, objetos y funciones.

Los métodos de arreglos son funciones predefinidas que se utilizan para manipular y transformar los arreglos. Estos métodos son el pilar fundamental para trabajar de manera libre y eficiente con JavaScript.

## forEach()

El método `forEach()` es una forma sencilla de recorrer todos los elementos de un arreglo y realizar una acción en cada uno de ellos. Este método ejecuta una función para cada elemento del arreglo.

La función proporcionada como argumento a `forEach()` recibe tres argumentos:

1. El valor del elemento actual
    
2. El índice del elemento actual
    
3. El arreglo que se está recorriendo
    

```javascript
const array1 = ['a', 'b', 'c'];

array1.forEach(element => console.log(element));

// Output:
// "a"
// "b"
// "c"
```

## map()

El método `map()` es una forma eficiente de transformar los elementos de un arreglo en otros elementos. Este método crea un nuevo arreglo con los resultados de la llamada a una función para cada elemento del arreglo.

La función proporcionada como argumento a `map()` recibe tres argumentos:

1. El valor del elemento actual
    
2. El índice del elemento actual
    
3. El arreglo que se está recorriendo
    

```javascript
const array1 = [1, 4, 9, 16];

const map1 = array1.map(x => x * 2);

console.log(map1);

// Output: [2, 8, 18, 32]
```

## filter()

El método `filter()` es una forma útil de filtrar los elementos de un arreglo y obtener solo aquellos que cumplen ciertas condiciones. Este método crea un nuevo arreglo con todos los elementos que cumplan la condición implementada en la función proporcionada.

La función proporcionada como argumento a `filter()` recibe tres argumentos:

1. El valor del elemento actual
    
2. El índice del elemento actual
    
3. El arreglo que se está recorriendo
    

```javascript
const words = ['spray', 'limit', 'elite', 'exuberant', 'destruction', 'present'];

const result = words.filter(word => word.length > 6);

console.log(result);

// Output: ["exuberant", "destruction", "present"]
```

## reduce()

El método `reduce()` es una forma poderosa de reducir un arreglo a un solo valor. Este método aplica una función acumuladora que procesa cada elemento de un arreglo y devuelve un único valor.

La función proporcionada como argumento a `reduce()` recibe cuatro argumentos:

1. El acumulador
    
2. El valor del elemento actual
    
3. El índice del elemento actual
    
4. El arreglo que se está recorriendo
    

```javascript
const array1 = [1, 2, 3, 4];

const reducer = (accumulator, currentValue) => accumulator + currentValue;

// 1 + 2 + 3 + 4
console.log(array1.reduce(reducer));

// Output: 10
```

## find()

El método `find()` es una forma sencilla de encontrar el primer elemento que cumple cierta condición. Este método devuelve el valor del primer elemento del arreglo que cumple con la función de prueba proporcionada.

La función proporcionada como argumento a `find()` recibe tres argumentos:

1. El valor del elemento actual
    
2. El índice del elemento actual
    
3. El arreglo que se está recorriendo
    

```javascript
const array1 = [5, 12, 8, 130, 44];

const found = array1.find(element => element > 10);

console.log(found);

// Output: 12
```

## findIndex()

El método `findIndex()` es una forma sencilla de encontrar el índice del primer elemento que cumple cierta condición. Este método devuelve el índice del primer elemento del arreglo que cumple con la función de prueba proporcionada.

La función proporcionada como argumento a `findIndex()` recibe tres argumentos:

1. El valor del elemento actual
    
2. El índice del elemento actual
    
3. El arreglo que se está recorriendo
    

```javascript
const array1 = [5, 12, 8, 130, 44];

const isLargeNumber = element => element > 13;

console.log(array1.findIndex(isLargeNumber));

// Output: 3
```

## every()

El método `every()` es una forma sencilla de comprobar si todos los elementos de un arreglo cumplen cierta condición. Este método comprueba si todos los elementos del arreglo pasan la prueba implementada por la función proporcionada.

La función proporcionada como argumento a `every()` recibe tres argumentos:

1. El valor del elemento actual
    
2. El índice del elemento actual
    
3. El arreglo que se está recorriendo
    

```javascript
const array1 = [1, 30, 39, 29, 10, 13];

const isBelowThreshold = currentValue => currentValue < 40;

console.log(array1.every(isBelowThreshold));

// Output: true
```

## some()

El método `some()` es una forma sencilla de comprobar si al menos un elemento de un arreglo cumple cierta condición. Este método comprueba si al menos un elemento del arreglo cumple con la prueba implementada por la función proporcionada.

La función proporcionada como argumento a `some()` recibe tres argumentos:

1. El valor del elemento actual
    
2. El índice del elemento actual
    
3. El arreglo que se está recorriendo
    

```javascript
const array1 = [1, 2, 3, 4, 5];

const even = element => element % 2 === 0;

console.log(array1.some(even));

// Output: true
```

## concat()

El método `concat()` se utiliza para fusionar dos o más arreglos en un solo arreglo. Este método no modifica los arreglos originales, sino que devuelve un nuevo arreglo que contiene los elementos de los arreglos originales.

```javascript
const array1 = ['a', 'b', 'c'];
const array2 = ['d', 'e', 'f'];
const array3 = ['g', 'h', 'i'];

const newArray = array1.concat(array2, array3);

console.log(newArray);

// Output: ["a", "b", "c", "d", "e", "f", "g", "h", "i"]
```

## slice()

El método `slice()` se utiliza para extraer una sección de un arreglo y devolver un nuevo arreglo con los elementos seleccionados. Este método no modifica el arreglo original.

El método `slice()` toma dos argumentos opcionales:

1. El índice de inicio (incluido)
    
2. El índice de fin (excluido)
    

```javascript
const array1 = ['a', 'b', 'c', 'd', 'e'];

const newArray = array1.slice(1, 4);

console.log(newArray);

// Output: ["b", "c", "d"]
```

Espero que esta guía te haya resultado útil y que lograste comprender los métodos de arreglos en JavaScript. Si tienes alguna pregunta o comentario, ¡no dudes en escribirme!

Si quieres profundizar en iteradores clave, te recomiendo el artículo

%[https://blog.devandmus.com/iteradores-clave-de-array-en-javascript] 

## Fuentes

* [MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array)
    
* [W3Schools](https://www.w3schools.com/jsref/jsref_obj_array.asp)
    
* [JavaScript.info](http://JavaScript.info)