JavaScript Enumerate Alternatives and Examples

JavaScript is a friendly little creature. It can loop, count, filter, map, and sort. But if you come from Python, you may look for enumerate() and say, “Where did it go?” Surprise. JavaScript does not have a built-in enumerate() function like Python does. But do not panic. We have many good alternatives.

TLDR: JavaScript does not have a native enumerate() function. You can use array.entries(), forEach(), map(), or a simple counter in a loop. For objects, use Object.entries(). If you really miss Python-style enumerate, you can build your own small helper.

What does “enumerate” mean?

To enumerate means to loop over items while also getting a number for each item. Usually, that number is the index.

Imagine a basket of fruit:

Apple
Banana
Cherry

If we enumerate it, we get:

0: Apple
1: Banana
2: Cherry

Simple. Useful. Tasty.

Why JavaScript has no built-in enumerate

Python has this:

for index, item in enumerate(fruits):
    print(index, item)

JavaScript does not. But JavaScript has many loop tools. Some are old. Some are shiny. Some are perfect for arrays. Some are better for objects.

So instead of one magic word, JavaScript gives you a toolbox. It is like getting a whole kitchen instead of one spoon.

Alternative 1: Use `array.entries()`

This is the closest built-in option to Python’s enumerate(). It gives you pairs. Each pair has an index and a value.

const fruits = ["Apple", "Banana", "Cherry"];

for (const [index, fruit] of fruits.entries()) {
  console.log(index, fruit);
}

The output is:

0 Apple
1 Banana
2 Cherry

This is clean. It is modern. It works nicely with for...of.

Use this when:

You want a simple index and value.
You are looping through an array.
You like readable code.

Fun fact: entries() returns an iterator. That means it gives values one at a time. Like a polite waiter bringing one plate after another.

Alternative 2: Use `forEach()`

forEach() is very popular. It runs a function for each array item. It also gives you the index as the second argument.

const animals = ["Cat", "Dog", "Otter"];

animals.forEach((animal, index) => {
  console.log(index, animal);
});

The output is:

0 Cat
1 Dog
2 Otter

This style is short and friendly. It is great for quick actions, like logging, updating the page, or building simple lists.

Use this when:

You do not need to stop the loop early.
You want clear and compact code.
You are doing something for each item.

One warning: You cannot use break inside forEach(). If you need to stop early, use a regular for loop or for...of.

Alternative 3: Use a classic `for` loop

Ah, the classic. The old bicycle of JavaScript loops. It still works. It still gets you there.

const colors = ["Red", "Green", "Blue"];

for (let index = 0; index < colors.length; index++) {
  console.log(index, colors[index]);
}

This gives:

0 Red
1 Green
2 Blue

This version is a little longer. But it gives you full control. You can skip items. You can stop early. You can count backward. You can do loop gymnastics if you want.

Use this when:

You need maximum control.
You need break or continue.
You want to loop in a custom way.

Image not found in postmeta

Alternative 4: Use `map()` when creating a new array

map() is not just for looping. It is for transforming. It creates a new array from an old one.

const names = ["Mia", "Leo", "Zoe"];

const numberedNames = names.map((name, index) => {
  return `${index + 1}. ${name}`;
});

console.log(numberedNames);

The output is:

["1. Mia", "2. Leo", "3. Zoe"]

Notice we used index + 1. Array indexes start at 0. Humans often prefer lists that start at 1. Humans are dramatic like that.

Use this when:

You want a new array.
You want to transform each item.
You need the index during that transformation.

Do not use map() if you only want to print values or cause side effects. Use forEach() or a loop instead.

Alternative 5: Enumerate object properties with `Object.entries()`

Arrays are not the only things we loop through. Sometimes we have objects.

const user = {
  name: "Ava",
  role: "Admin",
  level: 7
};

To enumerate keys and values, use Object.entries():

Object.entries(user).forEach(([key, value], index) => {
  console.log(index, key, value);
});

The output is:

0 name Ava
1 role Admin
2 level 7

This is very handy. It gives you the index, the key, and the value. A tiny data party.

Use this when:

You are working with plain objects.
You need both property names and values.
You want to build tables, forms, or debug output.

Alternative 6: Build your own `enumerate()`

If you really want a Python-like helper, make one. JavaScript is flexible. It does not mind.

function* enumerate(array) {
  let index = 0;

  for (const item of array) {
    yield [index, item];
    index++;
  }
}

Now you can use it like this:

const snacks = ["Chips", "Cookies", "Popcorn"];

for (const [index, snack] of enumerate(snacks)) {
  console.log(index, snack);
}

The result:

0 Chips
1 Cookies
2 Popcorn

This uses a generator function. That is what the * means. A generator can pause and resume. It is like a loop with a pause button.

You can also add a custom start number:

function* enumerate(array, start = 0) {
  let index = start;

  for (const item of array) {
    yield [index, item];
    index++;
  }
}

for (const [index, snack] of enumerate(snacks, 1)) {
  console.log(index, snack);
}

Now the list starts at 1. Fancy.

Which option should you choose?

Here is the simple guide:

Use array.entries() for clean index and value loops.
Use forEach() for simple work on every item.
Use a classic for loop when you need control.
Use map() when you want a new array.
Use Object.entries() for object keys and values.
Use a custom enumerate() when you want reusable Python-style code.

Common mistakes

Mistake 1: Using map() without returning anything.

items.map((item, index) => {
  console.log(index, item);
});

This works, but it is not the best use of map(). Use forEach() instead.

Mistake 2: Forgetting that indexes start at 0.

If you show numbers to users, you may want index + 1.

Mistake 3: Using for...in on arrays.

for (const index in fruits) {
  console.log(index, fruits[index]);
}

This can work, but it is usually not the best choice. for...in is meant for object keys. For arrays, prefer for...of, entries(), or forEach().

Final thoughts

JavaScript may not have a built-in enumerate(), but it has plenty of good choices. The best one depends on the job. Need index and value? Use entries(). Need a new array? Use map(). Need object keys? Use Object.entries().

Think of enumeration as adding little name tags to your data. Each item gets a number. Each loop gets clearer. And your code becomes easier to read, debug, and enjoy.

What does “enumerate” mean?

Why JavaScript has no built-in enumerate

Alternative 1: Use array.entries()

Alternative 2: Use forEach()

Alternative 3: Use a classic for loop

Alternative 4: Use map() when creating a new array

Alternative 5: Enumerate object properties with Object.entries()

Alternative 6: Build your own enumerate()

Which option should you choose?

Common mistakes

Final thoughts

Alternative 1: Use `array.entries()`

Alternative 2: Use `forEach()`

Alternative 3: Use a classic `for` loop

Alternative 4: Use `map()` when creating a new array

Alternative 5: Enumerate object properties with `Object.entries()`

Alternative 6: Build your own `enumerate()`