Other Useful Array Methods in JavaScript

Other Useful Array Methods in JavaScript

Beyond map/filter/reduce, JavaScript has many useful array methods. Here is when to use each.

find: First Match

const user = users.find((u) => u.id === 5); // first match or undefined
``
Returns the first matching element. Stops at the first match (early exit).

### findIndex: Index of First Match

```js
const index = users.findIndex((u) => u.id === 5); // index or -1
``
### some: At Least One Match

```js
const hasAdult = users.some((u) => u.age >= 18); // true or false
``
Returns `true` if at least one element passes the test. Stops at the first truthy (early exit).

### every: All Match

```js
const allAdults = users.every((u) => u.age >= 18); // true or false
``
Returns `true` if all elements pass the test. Stops at the first falsy (early exit).

### forEach: Iterate for Side Effects

```js
arr.forEach((n) => console.log(n)); // no return value
``
Use for side effects. Do not use if you need the return value (use `map`).

### sort: Sort In Place

```js
[3, 1, 2].sort((a, b) => a - b); // [1, 2, 3] (numeric)
["b", "a", "c"].sort(); // ["a", "b", "c"] (default string)
``
**Warning**: `sort` mutates the original array. Use `[...arr].sort()` for immutability. Always pass a comparator for numbers.

### flat: Flatten

```js
[[1, 2], [3, 4]].flat(); // [1, 2, 3, 4] (one level)
[1, [2, [3, [4]]]].flat(Infinity); // [1, 2, 3, 4] (all levels)
``
### flatMap: map + flat

```js
[1, 2, 3].flatMap((n) => [n, n * 2]); // [1, 2, 2, 4, 3, 6]
``
`flatMap` is `map` followed by `flat(1)`. Useful for mapping to arrays and flattening.

### includes: Contains

```js
[1, 2, 3].includes(2); // true
``
### indexOf / lastIndexOf

```js
[1, 2, 3, 2].indexOf(2); // 1
[1, 2, 3, 2].lastIndexOf(2); // 3
``
### slice: Copy a Portion

```js
[1, 2, 3, 4].slice(1, 3); // [2, 3]
[1, 2, 3, 4].slice(-2); // [3, 4]
``
### splice: Add/Remove In Place

```js
const arr = [1, 2, 3];
arr.splice(1, 1); // [2] (removed), arr is [1, 3]
``
**Warning**: `splice` mutates. Use `filter` or `slice` for immutability.

### join: Array to String

```js
["a", "b", "c"].join(", "); // "a, b, c"
``
### The Takeaway

Beyond `map`/`filter`/`reduce`: `find` (first match), `some`/`every` (boolean), `forEach` (side effects), `sort` (sort in place, use a comparator), `flat`/`flatMap` (flatten), `includes` (contains), `slice` (copy portion), `join` (to string). Use the right method for each task.