How to Map Over Object Properties in JavaScript

By the end of this page, you will understand why plain JavaScript objects do not have a built-in map() method, and how developers typically achieve the same result using Object.keys(), Object.entries(), Object.fromEntries(), loops, or small helper functions. You will also learn when to use an object versus an array for transformations.

Plain JavaScript objects and arrays are different data structures.

• Arrays are ordered collections and come with array methods like map(), filter(), and reduce().
• Objects are key-value collections and do not have a built-in map() method.

So the direct answer is: No, JavaScript does not provide a native map() method for plain objects.

However, you can still "map over" an object's properties by converting the object into something iterable, transforming it, and then turning it back into an object.

A common modern pattern is:

1. Get the object's entries with Object.entries(obj)
2. Use array methods like map()
3. Rebuild an object with Object.fromEntries()

Example:

const myObject = { a: 1, b: 2, c: 3 };

const newObject = Object.fromEntries(
  Object.(myObject).( [key, value * value])
);

.(newObject); 

Think of an array as a row of numbered boxes:

• box 0
• box 1
• box 2

Because arrays are ordered, JavaScript gives them tools like map() to process each box in sequence.

Think of an object as a set of labeled drawers:

• drawer a
• drawer b
• drawer c

Objects are organized by keys, not by numeric positions. Since they are not arrays, they do not automatically get array methods like map().

So when you want to "map an object," you usually:

1. open all the labeled drawers (Object.entries())
2. transform each drawer's contents (map())
3. rebuild the cabinet (Object.fromEntries())

That is the core idea.

The most common ways to transform object values are shown below.

1. Using Object.entries() and Object.fromEntries()

const myObject = { a: 1, b: 2, c: 3 };

const squared = Object.fromEntries(
  Object.entries(myObject).map(([key, value]) => [key, value * value])
);

console.log(squared); // { a: 1, b: 4, c: 9 }

How it works

• Object.entries(myObject) returns:

[['a', 1], ['b', 2], ['c', 3]]

• Then .map() transforms each [key, value]
• Object.fromEntries() builds a new object from the transformed pairs

Consider this example:

const myObject = { a: 1, b: 2, c: 3 };

const result = Object.fromEntries(
  Object.entries(myObject).map(([key, value]) => [key, value * 2])
);

console.log(result);

Here is what happens step by step.

Step 1: Start with the original object

{ a: 1, b: 2, c: 3 }

Step 2: Convert the object into entries

Object.entries(myObject)

Result:

[['a', 1], ['b', 2], [, ]]

Object mapping is useful whenever you need to transform values while keeping the same keys.

Common examples

1. Formatting API response data

const prices = { apple: 1.2, banana: 0.8 };

const formatted = Object.fromEntries(
  Object.entries(prices).map(([key, value]) => [key, `$${value.toFixed(2)}`])
);

console.log(formatted); // { apple: '$1.20', banana: '$0.80' }

2. Converting configuration values

const envConfig = { port: '3000', debug: 'true' };

const parsed = {
  port: Number(envConfig.port),
  debug: envConfig.debug === 'true'
};

Or with a helper when rules are consistent.

3. Normalizing imported data

In real projects, developers usually do not try to add map() directly to all objects. Instead, they use one of these patterns.

1. Small utility function

A reusable helper keeps code clean.

function mapObjectValues(obj, transform) {
  return Object.fromEntries(
    Object.entries(obj).map(([key, value]) => [key, transform(value, key)])
  );
}

This is common in service layers, data formatting utilities, and validation modules.

2. Guard clauses before transformation

Real code often validates input first.

function mapObjectValues(obj, transform) {
  if (obj === null || typeof obj !== 'object' || Array.isArray(obj)) {
    throw new TypeError('Expected a plain object');
  }

  return Object.(
    .(obj).( [key, (value, key)])
  );
}

1. Trying to call .map() directly on an object

This does not work:

const obj = { a: 1, b: 2 };
obj.map((value) => value * 2);

Why it fails:

• plain objects do not have a map() method

Use this instead:

const result = Object.fromEntries(
  Object.entries(obj).map(([key, value]) => [key, value * 2])
);

2. Using Object.keys() but forgetting to build a new object

Broken idea:

const obj = { a: 1, b: 2 };
const result = Object.(obj).( obj[key] * );

.(result); 

// No native object.map() exists for plain objects

Common pattern

const result = Object.fromEntries(
  Object.entries(obj).map(([key, value]) => [key, transform(value, key)])
);

Reusable helper

function mapObject(obj, fn) {
  return Object.fromEntries(
    Object.entries(obj).map(([key, value]) => [key, fn(value, key)])
  );
}

Alternatives

Using Object.keys()

const result = {};
Object.keys(obj).forEach(() => {
  result[key] = (obj[key], key);
});

Is there a native map() for JavaScript objects?

No. Plain objects do not have a built-in map() method.

What is the modern way to map over an object in JavaScript?

The most common modern approach is:

Object.fromEntries(
  Object.entries(obj).map(([key, value]) => [key, transform(value, key)])
)

Can I use Object.keys() instead of Object.entries()?

Yes. Object.keys() works well if you only need the keys and can access values with obj[key].

Why does Object.keys(obj).map(...) return an array?

Because Object.keys(obj) returns an array, and array map() always returns a new array.

Should I add map() to Object.prototype?

• Object.keys() — used to get an array of an object's own keys.
• Object.values() — useful when only the values matter.
• Object.entries() — the most convenient way to work with both keys and values.
• Object.fromEntries() — rebuilds an object after mapping or filtering entries.
• Array.prototype.map() — the array method that inspires object-mapping patterns.
• Array.prototype.reduce() — another way to build a new object from entries.
• for...of loop — commonly used with Object.entries() for readable iteration.
• for...in loop — older object iteration syntax that requires care.
• Plain objects vs arrays — important for choosing the right data structure.