JavaScript Array Methods You Must Know in 2026

Why Array Methods Matter

Arrays are the backbone of JavaScript programming. Whether you're fetching data from an API, managing state in React, or processing user input — you're working with arrays. Mastering JavaScript's built-in array methods will make your code cleaner, more readable, and more performant.

forEach — Iterate Over Arrays

The forEach method executes a function once for each array element. It doesn't return a new array — it simply iterates.

const fruits = ['apple', 'banana', 'cherry'];

fruits.forEach((fruit, index) => {
  console.log(`${index}: ${fruit}`);
});
// 0: apple
// 1: banana
// 2: cherry

map — Transform Every Element

The map method creates a new array by applying a function to each element. This is one of the most commonly used array methods in modern JavaScript and React development.

const numbers = [1, 2, 3, 4, 5];
const doubled = numbers.map(n => n * 2);
console.log(doubled); // [2, 4, 6, 8, 10]

const users = [
  { name: 'Alice', age: 25 },
  { name: 'Bob', age: 30 }
];
const names = users.map(user => user.name);
console.log(names); // ['Alice', 'Bob']

filter — Select Elements Based on Condition

The filter method creates a new array with all elements that pass a test (provided as a function).

const numbers = [1, 2, 3, 4, 5, 6, 7, 8];
const evens = numbers.filter(n => n % 2 === 0);
console.log(evens); // [2, 4, 6, 8]

const users = [
  { name: 'Alice', active: true },
  { name: 'Bob', active: false },
  { name: 'Charlie', active: true }
];
const activeUsers = users.filter(user => user.active);
console.log(activeUsers.length); // 2

reduce — Accumulate Into a Single Value

The reduce method reduces an array to a single value by executing a reducer function on each element. It's incredibly powerful for calculations, grouping data, and more.

const numbers = [1, 2, 3, 4, 5];
const sum = numbers.reduce((accumulator, current) => {
  return accumulator + current;
}, 0);
console.log(sum); // 15

// Count occurrences
const fruits = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple'];
const count = fruits.reduce((acc, fruit) => {
  acc[fruit] = (acc[fruit] || 0) + 1;
  return acc;
}, {});
console.log(count); // { apple: 3, banana: 2, cherry: 1 }

find and findIndex

find returns the first element that matches a condition. findIndex returns its index.

const users = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  { id: 3, name: 'Charlie' }
];

const bob = users.find(user => user.name === 'Bob');
console.log(bob); // { id: 2, name: 'Bob' }

const bobIndex = users.findIndex(user => user.name === 'Bob');
console.log(bobIndex); // 1

some and every — Boolean Checks

some checks if at least one element passes a test. every checks if all elements pass.

const numbers = [2, 4, 6, 8];
console.log(numbers.every(n => n % 2 === 0)); // true
console.log(numbers.some(n => n > 5));         // true

const ages = [15, 22, 18, 30];
const allAdults = ages.every(age => age >= 18);
console.log(allAdults); // false

flat and flatMap

flat flattens nested arrays. flatMap maps and then flattens by one level.

const nested = [1, [2, 3], [4, [5, 6]]];
console.log(nested.flat());    // [1, 2, 3, 4, [5, 6]]
console.log(nested.flat(2));   // [1, 2, 3, 4, 5, 6]

const sentences = ['Hello World', 'Goodbye Moon'];
const words = sentences.flatMap(s => s.split(' '));
console.log(words); // ['Hello', 'World', 'Goodbye', 'Moon']

Chaining Array Methods

The real power comes from chaining multiple methods together for clean, readable data transformations.

const products = [
  { name: 'Laptop', price: 999, inStock: true },
  { name: 'Phone', price: 699, inStock: false },
  { name: 'Tablet', price: 449, inStock: true },
  { name: 'Watch', price: 299, inStock: true }
];

const affordableInStock = products
  .filter(p => p.inStock)
  .filter(p => p.price < 500)
  .map(p => p.name);

console.log(affordableInStock); // ['Tablet', 'Watch']

Performance Tips

• Avoid for...in loops on arrays — use for...of or array methods instead
• Use some() instead of filter().length > 0 for boolean checks
• Prefer find() over filter()[0] when you only need the first match
• Be cautious with reduce() — if it makes code harder to read, use simpler methods