How to Convert an Array to a Dictionary in TypeScript

The quickest way to convert an array to a dictionary in TypeScript is Object.fromEntries(): map each item to a [key, value] pair and type the result as a Record. Here’s the one-liner I use for an array of objects keyed by id:

const byId: Record<string, Employee> = Object.fromEntries(
  employees.map((e) => [e.id, e]),
);

Every snippet below ran in strict mode on TypeScript 7.0.2 and Node.js v22.22.2, and each output block is pasted straight from my console.

Convert an array of objects to a dictionary with Object.fromEntries()

Say you look up Austin and Denver employees by id all day. Calling find() scans the whole array each time; a dictionary gives you a direct lookup. If typed object arrays are new to you, start with arrays of objects in TypeScript.

interface Employee {
  id: string;
  name: string;
  city: string;
  salaryUSD: number;
}

const employees: Employee[] = [
  { id: "E101", name: "Ava Thompson", city: "Austin", salaryUSD: 98500 },
  { id: "E102", name: "Liam Carter", city: "Denver", salaryUSD: 87250.5 },
  { id: "E103", name: "Mia Rodriguez", city: "Austin", salaryUSD: 104000 },
];

const byId: Record<string, Employee> = Object.fromEntries(
  employees.map((e) => [e.id, e]),
);

console.log(byId["E102"].name);              // direct lookup, no find()
console.log(Object.keys(byId));

Output:

Liam Carter
[ 'E101', 'E102', 'E103' ]

The value can be any field you put in the pair. It’s the same idea as mapping an array of objects in TypeScript.

If you only need one entry, I show the typed options to get the first element from a TypeScript dictionary.

Build the dictionary with reduce()

Many codebases use reduce() instead, but in strict mode an untyped {} seed won’t compile:

// Employee interface and employees array from the first example

const byId = employees.reduce((acc, e) => {
  acc[e.id] = e;
  return acc;
}, {});

Output:

dict_reduce_err.ts(15,3): error TS7053: Element implicitly has an 'any' type because expression of type 'string' can't be used to index type '{}'.
  No index signature with a parameter of type 'string' was found on type '{}'.

The fix is to pass the result type as reduce’s generic argument. I mutate the accumulator, because spreading {...acc} copies it every time:

// Employee interface and employees array from the first example

const byId = employees.reduce<Record<string, Employee>>((acc, e) => {
  acc[e.id] = e;                              // mutate the accumulator, no spread copy
  return acc;
}, {});

console.log(byId["E103"].city, byId["E103"].salaryUSD.toFixed(2));

Output:

Austin 104000.00

Everything else reduce() can do is in my guide to the array reduce method in TypeScript.

Convert an array to a dictionary with a for…of loop or forEach

A plain loop is easy to debug, and it handles string arrays too, like counting orders per state:

// Employee interface and employees array from the first example

const nameById: Record<string, string> = {};
for (const e of employees) {
  nameById[e.id] = e.name;
}
console.log(nameById);

const states: string[] = ["TX", "CA", "TX", "NY", "TX", "CA"];
const ordersByState: Record<string, number> = {};
states.forEach((s) => {
  ordersByState[s] = (ordersByState[s] ?? 0) + 1;
});
console.log(ordersByState);

Output:

{ E101: 'Ava Thompson', E102: 'Liam Carter', E103: 'Mia Rodriguez' }
{ TX: 3, CA: 2, NY: 1 }

The ?? 0 starts each new key at zero. For a comparison of loop styles, see how to loop through an array in TypeScript and the forEach() method.

Write a reusable toDictionary() helper

If you convert arrays often, a generic helper keeps the types right. Pass a key picker and, optionally, a value picker:

// Employee interface and employees array from the first example

function toDictionary<T, K extends PropertyKey, V = T>(
  items: readonly T[],
  getKey: (item: T) => K,
  getValue: (item: T) => V = (item) => item as unknown as V,
): Record<K, V> {
  const result = {} as Record<K, V>;
  for (const item of items) {
    result[getKey(item)] = getValue(item);
  }
  return result;
}

const byId = toDictionary(employees, (e) => e.id);
const payById = toDictionary(employees, (e) => e.id, (e) => e.salaryUSD.toLocaleString("en-US", { style: "currency", currency: "USD" }));
console.log(byId["E101"].name, "|", payById);

const lookup: Record<string, Employee | undefined> = byId;
const missing = lookup["E999"];
console.log("E999:", missing?.name ?? "not found", "| hasOwn:", Object.hasOwn(byId, "E999"));

Output:

Ava Thompson | { E101: '$98,500.00', E102: '$87,250.50', E103: '$104,000.00' }
E999: not found | hasOwn: false

Watch that last line. A Record<string, Employee> claims every key exists, so byId["E999"].name compiles yet crashes at runtime. Widen lookups to Employee | undefined, check Object.hasOwn(), or enable noUncheckedIndexedAccess.

What happens to duplicate keys in a dictionary?

Keying by city drops one of the two Austin employees. Every method in this article keeps the last value. When you need all of them, use Object.groupBy() (ES2024):

// Employee interface and employees array from the first example

const byCity = Object.fromEntries(employees.map((e) => [e.city, e.name]));
console.log("last one wins:", byCity);

const groups = Object.groupBy(employees, (e) => e.city);
for (const [city, people] of Object.entries(groups)) {
  console.log(city, "->", people?.map((p) => p.name).join(", "));
}

Output:

last one wins: { Austin: 'Mia Rodriguez', Denver: 'Liam Carter' }
Austin -> Ava Thompson, Mia Rodriguez
Denver -> Liam Carter

Should you use a Map instead of an object?

A Map is TypeScript’s other dictionary. It keeps key types and has size and has() built in:

// Employee interface and employees array from the first example

const byId = new Map(employees.map((e) => [e.id, e]));
console.log(byId.get("E101")?.name, "| size:", byId.size, "| has E999:", byId.has("E999"));

const zipCodes = [78701, 80202, 60601];
const asObject = Object.fromEntries(zipCodes.map((z) => [z, true]));
const asMap = new Map(zipCodes.map((z) => [z, true]));
console.log("object keys:", Object.keys(asObject));
console.log("map keys:   ", [...asMap.keys()]);

Output:

Ava Thompson | size: 3 | has E999: false
object keys: [ '60601', '78701', '80202' ]
map keys:    [ 78701, 80202, 60601 ]

Notice the object turned the ZIP codes into strings and sorted them, while the Map kept numbers in insertion order. I go deeper in creating a Map from an array in TypeScript.

Approach	Result type	Best for
Object.fromEntries()	Record<string, T>	Short, readable one-liners
reduce<Record<...>>()	Record<string, T>	Extra logic per item
Object.groupBy()	Partial<Record<K, T[]>>	Keys that repeat
new Map()	Map<K, T>	Non-string keys, frequent updates

Here are a few related TypeScript guides to read next:

• Work with key-value pairs in TypeScript
• Merge Maps in TypeScript
• Find an object in a TypeScript array
• TypeScript interface for an array of objects

Frequently asked questions