Array.prototype.map(callback) builds a new array by calling callback on every element and collecting each return value. Length stays the same; the source array is not mutated. For side effects only, prefer forEach(). To keep some items and drop others, use filter().
array.map(callback)
array.map((element, index, array) => ...)
[1, 2, 3].map(n => n * 2) → [2, 4, 6]
["a", "b"].map(s => s.toUpperCase()) → ["A", "B"]
returns a new array (same length)
original array unchanged
always return a value from the callbackCall array.map. Start with this line.
array.map(callback)| Call | What it does |
|---|---|
array.map(callback) | Primary signature. |
array.map(...) | Call with the arguments your case needs. |
Built into JavaScript. Call map(...) on an array instance — no import required.
array.map(callback)| Parameter | Description |
|---|---|
| callback | Required. Runs once per element; return the new value |
| index | Optional. Current index (0-based) |
| Return Value | Description |
|---|---|
| * | New array of the same length |
Return a new value for every element.
const nums = [1, 2, 3, 4];
const doubled = nums.map(n => n * 2);
console.log(JSON.stringify(doubled)); // [2,4,6,8]
console.log(JSON.stringify(nums)); // [1,2,3,4] unchanged1→2, 2→4, 3→6, 4→8.doubled.nums is still [1, 2, 3, 4].Pull one property from each object into a simpler array.
const users = [
{ id: 1, name: "Ada" },
{ id: 2, name: "Grace" }
];
const names = users.map(u => u.name);
const labels = users.map((u, i) => (i + 1) + ". " + u.name);
console.log(JSON.stringify(names)); // ["Ada","Grace"]
console.log(JSON.stringify(labels)); // ["1. Ada","2. Grace"]u.name becomes each new element.i + 1.users is unchanged; you only built new arrays.map vs forEachmap returns data; forEach returns undefined.
const nums = [1, 2, 3];
const mapped = nums.map(n => n * 10);
const each = nums.forEach(n => n * 10);
console.log(JSON.stringify(mapped)); // [10,20,30]
console.log(String(each)); // undefinedmapped.undefined.map; only side effects → forEach.forEach to a variable expecting data.Array.prototype.map() is part of ES5 (2009). It has been available in evergreen browsers and Node.js for a long time.
Supported in all modern browsers, Internet Explorer 9+, and every current Node.js release.
Bottom line: Safe everywhere. Prefer map() when you need a new array; use forEach() only for side effects.
Remove and return the last element of an array.
11 people found this page helpful