JavaScript Array entries() Method

What You’ll Learn

The entries() method returns an iterator of [index, value] pairs for every element in an array. This tutorial covers syntax, five examples, destructuring, comparison with keys() and values(), and when to pick an iterator over forEach.

Introduction

Arrays in JavaScript are ordered lists, but sometimes you need more than the value alone—you also need the index. The entries() method gives you both at once as a stream of two-item arrays.

It is part of the same iterator family as keys() and values(), and it works naturally with for...of loops and array destructuring.

Understanding the entries() Method

Calling array.entries() does not loop immediately. It returns a fresh Array Iterator object. Each time the iterator advances, it produces another pair: the numeric index and the element stored at that index.

For ['red', 'green', 'blue'], the iterator yields [0, 'red'], then [1, 'green'], then [2, 'blue'].

📝 Syntax

General form of Array.prototype.entries:

array.entries()

Parameters

• None. entries() takes no arguments.

Return value

• A new Array Iterator object.
• Each iterator step returns [index, value].
• The original array is not modified.

Common patterns

• for (const entry of arr.entries()) — loop all pairs.
• for (const [i, v] of arr.entries()) — destructure index and value.
• Array.from(arr.entries()) — materialize pairs into a nested array.
• Object.fromEntries(arr.entries()) — build an object keyed by index (strings).

Examples Gallery

Open DevTools Console (F12) or use Try-it labs. Example N maps to ?tryit=N.

const colors = ["red", "green", "blue"];
const iterator = colors.entries();

for (const entry of iterator) {
  console.log(entry);
}
// [0, "red"]
// [1, "green"]
// [2, "blue"]

[0, "red"]
[1, "green"]
[2, "blue"]

const colors = ["red", "green", "blue"];

for (const [index, value] of colors.entries()) {
  console.log(`Index: ${index}, Value: ${value}`);
}
// Index: 0, Value: red
// Index: 1, Value: green
// Index: 2, Value: blue

Index: 0, Value: red
Index: 1, Value: green
Index: 2, Value: blue

const colors = ["red", "green", "blue"];

for (const [index, value] of colors.entries()) {
  console.log(`Color at index ${index}: ${value}`);
}
// Color at index 0: red
// Color at index 1: green
// Color at index 2: blue

Color at index 0: red
Color at index 1: green
Color at index 2: blue

const colors = ["red", "green", "blue"];
const target = "green";

for (const [index, value] of colors.entries()) {
  if (value === target) {
    console.log(`Found ${target} at index ${index}`);
    break;
  }
}
// Found green at index 1

Found green at index 1

const scores = [88, 92, 75];

const pairs = [...scores.entries()];
console.log(pairs);
// [[0, 88], [1, 92], [2, 75]]

const lookup = Object.fromEntries(scores.entries());
console.log(lookup);
// { "0": 88, "1": 92, "2": 75 }

[[0, 88], [1, 92], [2, 75]]
{ "0": 88, "1": 92, "2": 75 }

🚀 Common Use Cases

• Indexed logging — print debug output with stable positions.
• Custom search — walk elements while tracking index for early exit.
• Data transforms — map pairs to new structures with Array.from.
• Object conversion — feed pairs into Object.fromEntries.
• Parallel arrays — compare or zip when index alignment matters.
• Teaching iterators — gentle introduction to the ES2015 iterator protocol.

📝 Notes

• Indexes are always numbers starting at 0, even if the array has holes.
• Holey slots still get an index; the value may be undefined.
• Iterators do not reflect later mutations unless you create a new iterator.
• Spreading arr.entries() consumes the iterator; call entries() again for a fresh pass.
• Object.fromEntries(arr.entries()) produces string keys ("0", "1", …).
• Also available on typed arrays with the same behavior.

💡 Best Practices