The map() method creates a new array by applying a provided function (callbackFn) to each element of the original array. It’s perfect for transforming data without modifying the original array.

Syntax

array.map(callbackFn, thisArg)

• callbackFn: A function that runs on each array element, with the following arguments:
  • element: Current element.
  • index: Current index.
  • array: The array being traversed.
• thisArg (optional): A value to use as this in the callback function.

Key Features

1. Returns a New Array: The original array remains unchanged.
2. Skips Empty Slots: Callback is not called for unassigned elements in sparse arrays.
3. Generic Usage: Works with array-like objects (e.g., NodeLists).

Examples

1. Basic Example: Transform Numbers

const numbers = [1, 4, 9];
const roots = numbers.map((num) => Math.sqrt(num));
console.log(roots); // [1, 2, 3]

2. Reformat Objects

const kvArray = [
  { key: 1, value: 10 },
  { key: 2, value: 20 },
];
const reformatted = kvArray.map(({ key, value }) => ({ [key]: value }));
console.log(reformatted); // [{ 1: 10 }, { 2: 20 }]

3. Using parseInt with map

// Common mistake:
console.log(["1", "2", "3"].map(parseInt)); // [1, NaN, NaN]

// Correct approach:
console.log(["1", "2", "3"].map((str) => parseInt(str, 10))); // [1, 2, 3]

// Alternative:
console.log(["1", "2", "3"].map(Number)); // [1, 2, 3]

4. Avoid Undefined Results

Returning nothing from the callback leads to undefined in the new array:

const numbers = [1, 2, 3, 4];
const result = numbers.map((num, index) => (index < 3 ? num : undefined));
console.log(result); // [1, 2, 3, undefined]

Use filter() or flatMap() to remove undesired elements.

5. Side Effects (Anti-Pattern)

Avoid using map() for operations with side effects, like updating variables:

const cart = [5, 15, 25];
let total = 0;

// Avoid this:
const withTax = cart.map((cost) => {
  total += cost;
  return cost * 1.2;
});

// Instead, use separate methods:
const total = cart.reduce((sum, cost) => sum + cost, 0);
const withTax = cart.map((cost) => cost * 1.2);

6. Accessing Other Array Elements

The third argument (array) allows accessing neighbors during transformations:

const numbers = [3, -1, 1, 4];
const averaged = numbers.map((num, idx, arr) => {
  const prev = arr[idx - 1] || 0;
  const next = arr[idx + 1] || 0;
  return (prev + num + next) / 3;
});
console.log(averaged);

Common Use Cases

1. Transform Data: Apply a function to each element.
2. Reformat Objects: Change the structure of data.
3. Map NodeLists: Transform DOM elements like NodeList into arrays:

   const elems = document.querySelectorAll("option:checked");
   const values = Array.from(elems).map(({ value }) => value);

When to Avoid map()

• No Return Value Needed: Use forEach() or for...of instead.
• Mutating Data: Create new objects instead of altering the original ones:

   const products = [{ name: "phone" }];
   const updated = products.map((p) => ({ ...p, price: 100 }));

Final Tips

• Pure Functions Only: Ensure the callback has no side effects.
• Understand Arguments: Know that map() passes element, index, and array to the callback.
• Avoid Sparse Arrays: Empty slots will remain empty.

Use map() to simplify your code when transforming arrays efficiently!