Lodash _.transform() Method

What You’ll Learn

By the end of this tutorial, you’ll use _.transform() to build new objects and aggregates with a mutable accumulator.

What Is _.transform()?

_.transform() is Lodash’s object-friendly alternative to Array.prototype.reduce. You pass a collection, a callback, and an optional accumulator; Lodash walks own enumerable keys and lets you build a new result by mutating that accumulator each step.

Use it for data normalization, conditional filtering, grouping, and summing arrays. When every key stays and only values change, _.mapValues() may be simpler; when you need full control, reach for _.transform().

📝 Syntax

The signature takes a collection, iteratee, and optional starting accumulator:

_.transform(object, [iteratee], [accumulator])

Syntax Rules

• object — object or array to iterate (own enumerable keys).
• iteratee — (accumulator, value, key, collection) => void; mutate accumulator; return false to break.
• accumulator — optional seed; defaults to {} for objects.
• Return value — the final accumulator reference.
• Source — not modified; only the accumulator changes.

import transform from "lodash/transform";

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

const result = transform(data, (acc, value, key) => {
  acc[key.toUpperCase()] = value * 2;
}, {});

// result -> { A: 2, B: 4, C: 6 }

Examples Gallery

Practical _.transform() patterns with sample output and interactive Try It Yourself labs.

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

const transformed = _.transform(data, (result, value, key) => {
  result[key.toUpperCase()] = value * 2;
}, {});

console.log(transformed);
// -> { A: 2, B: 4, C: 6 }

{ A: 2, B: 4, C: 6 }

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

const filtered = _.transform(data, (result, value, key) => {
  if (value > 1) {
    result[key] = value;
  }
}, {});

console.log(filtered);
// -> { b: 2, c: 3 }

{ b: 2, c: 3 }

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

const transformed = _.transform(data, (result, obj, key) => {
  if (obj.value > 1) {
    result[key.toUpperCase()] = obj.value * 2;
  }
}, {});

console.log(transformed);
// -> { B: 4, C: 6 }

{ B: 4, C: 6 }

const data = [1, 2, 3];

const sum = _.transform(data, (result, value) => {
  result.total += value;
}, { total: 0 }).total;

console.log(sum);
// -> 6

6

const items = [
  { category: "fruit", name: "apple" },
  { category: "fruit", name: "banana" },
  { category: "veg", name: "carrot" }
];

const grouped = _.transform(items, (result, item) => {
  const cat = item.category;
  (result[cat] || (result[cat] = [])).push(item.name);
}, {});

console.log(grouped);
// -> { fruit: ["apple", "banana"], veg: ["carrot"] }

{ fruit: ["apple", "banana"], veg: ["carrot"] }

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

const viaTransform = _.transform(data, (acc, v) => {
  acc.sum += v;
}, { sum: 0 }).sum;

const viaReduce = _.reduce(data, (acc, v) => acc + v, 0);

console.log(viaTransform, viaReduce);
// -> 6 6

6 6

📝 Notes

• _.transform() does not mutate the source object or array—only the accumulator.
• Omit the accumulator to start with an empty object {} for object inputs.
• Return false from the iteratee to stop iteration early.
• Works on arrays too—pass a custom seed like { total: 0 } or [].
• For value-only mapping with the same keys, _.mapValues() is often clearer.
• Iteration covers own enumerable keys only (not inherited prototype properties).

💡 Best Practices