transform()

transform<T, Acc>(object, iteratee, accumulator): Acc

Iterates over own enumerable properties of object and accumulates a result.

💎 Why is this a Hidden Gem?

A more flexible alternative to reduce, designed specifically for objects.

DEPRECATED

Use Object.entries().reduce() directly instead.

---

Type Parameters

T: T extends object

The type of the object.

Acc: Acc

The type of the accumulator.

---

Parameters

object: T

The object to iterate over.

iteratee: (accumulator, value, key, object) => void

The function invoked per iteration.

accumulator: Acc

The initial value.

---

Returns: Acc

The accumulated value.

---

See Also

Object.entries() - MDN

---

Since

2.0.0

---

Also known as

transform (Lodash, es-toolkit) · ❌ (Remeda, Radashi, Ramda, Effect, Modern Dash, Antfu)

---

Example

// ❌ Deprecated approach
transform({ a: 1, b: 2, c: 1 }, (result, value, key) => {
  (result[value] ||= []).push(key);
}, {} as `Record<number, string[]>`);
// => { 1: ['a', 'c'], 2: ['b'] }

// ✅ Recommended approach
Object.entries({ a: 1, b: 2, c: 1 }).reduce((result, [key, value]) => {
  (result[value] ||= []).push(key);
  return result;
}, {} as `Record<number, string[]>`);
// => { 1: ['a', 'c'], 2: ['b'] }

---

How it works?

Iterates object properties and accumulates a result.

Processing Flow

Common Inputs

Object	Iteratee	Initial	Result
{a: 1, b: 2}	(r,v,k) => r[v] = k	{}	{1: 'a', 2: 'b'}

Deprecated: Use Object.entries().reduce() directly.

---

Use Cases

Accumulate from object 📌

Iterate and accumulate result.

#transform#accumulate#reduce#object

Object.entries(obj).reduce((acc, [key, value]) => {
  // transform logic
  return acc;
}, initialValue);

Group by value

Group keys by their values.

#group#invert#collect#values

const grouped = Object.entries({ a: 1, b: 2, c: 1 }).reduce(
  (acc, [k, v]) => {
    (acc[v] ||= []).push(k);
    return acc;
  },
  {} as Record<number, string[]>
);
// { 1: ['a', 'c'], 2: ['b'] }

Build an inverted lookup map

Create a reverse mapping from values to keys for fast lookups. Useful for enum reverse lookups, code-to-label mappings, and search indexes.

#invert#lookup#reverse#map#index#search

const statusCodes = { ok: 200, notFound: 404, serverError: 500 };

const codeToName = transform(statusCodes, (result, value, key) => {
  result[value] = key;
}, {} as Record<number, string>);
// => { 200: "ok", 404: "notFound", 500: "serverError" }

console.log(codeToName[404]); // => "notFound"

Filter and transform an object in one pass

Select and reshape object properties in a single iteration. More efficient than chaining filter + map on entries.

#filter#transform#single#pass#efficient#object#cleanup

const rawConfig = { host: "localhost", port: 3000, debug: "", verbose: null, timeout: 5000 };

const cleanConfig = transform(rawConfig, (result, value, key) => {
  if (value != null && value !== "") {
    result[key] = value;
  }
}, {} as Record<string, unknown>);
// => { host: "localhost", port: 3000, timeout: 5000 }