Lodash Wrapper .plant() Method

What You’ll Learn

By the end of this tutorial, you’ll use wrapper .plant(value) to replay an existing chain pipeline on new data without rebuilding the transforms.

What Is Wrapper .plant()?

Wrapper .plant(value) creates a new Lodash wrapper that keeps the same queued chain actions—such as map, filter, or take—but starts from a different wrapped value. Think of it as copying a pipeline template onto fresh data.

The original wrapper is untouched. After planting, you can unwrap with .value() or keep chaining on the new wrapper. This is especially handy when you built a reusable transform once and need to apply it to multiple datasets.

📝 Syntax

Pass the new starting value to .plant() on an existing wrapper:

const wrapped = _([1, 2]).map(function (n) { return n * n; });
const other = wrapped.plant([3, 4]);
// other is a new wrapper with the same map step

Syntax Rules

• One argument — the new value to wrap (array, object, or other data).
• Returns a wrapper — not plain data; call .value() to unwrap.
• Preserves chain actions — queued transforms from the source wrapper are replayed on the new value.
• Original unchanged — the source wrapper and its data stay independent.
• Chain after plant — you can add more steps on the planted wrapper before unwrapping.

import _ from "lodash";

function square(n) {
  return n * n;
}

const wrapped = _([1, 2]).map(square);
const other = wrapped.plant([3, 4]);

console.log(other.value());
// -> [9, 16]

console.log(wrapped.value());
// -> [1, 4]

Examples Gallery

Practical wrapper .plant() patterns with sample output and interactive Try It Yourself labs.

function square(n) {
  return n * n;
}

const wrapped = _([1, 2]).map(square);
const other = wrapped.plant([3, 4]);

console.log(other.value());
// -> [9, 16]

console.log(wrapped.value());
// -> [1, 4]

[9, 16]
[1, 4]

const pipeline = _([10, 20]).map(function (n) {
  return n / 10;
});

const batchA = pipeline.plant([100, 200]);
const batchB = pipeline.plant([5, 15]);

console.log(batchA.value());
// -> [10, 20]

console.log(batchB.value());
// -> [0.5, 1.5]

console.log(pipeline.value());
// -> [1, 2]

[10, 20]
[0.5, 1.5]
[1, 2]

const evensOnly = _([1, 2, 3]).filter(function (n) {
  return n % 2 === 0;
});

const setA = evensOnly.plant([1, 2, 3, 4, 5]);
const setB = evensOnly.plant([6, 7, 8, 9, 10]);

console.log(setA.value());
// -> [2, 4]

console.log(setB.value());
// -> [6, 8, 10]

[2, 4]
[6, 8, 10]

const doubled = _([1, 2, 3]).map(function (n) {
  return n * 2;
});

const result = doubled
  .plant([4, 5, 6])
  .take(2)
  .value();

console.log(result);
// -> [8, 10]

[8, 10]

function double(n) {
  return n * 2;
}

const pipeline = _([0]).map(double);
const viaPlant = pipeline.plant([1, 2, 3]).value();
const viaFresh = _([1, 2, 3]).map(double).value();

console.log(JSON.stringify(viaPlant) === JSON.stringify(viaFresh));
// -> true

true

function makeSquaredPipeline() {
  return _([0]).map(function (n) { return n * n; });
}

const squared = makeSquaredPipeline();

console.log(squared.plant([2, 3]).value());
// -> [4, 9]

console.log(squared.plant([5]).value());
// -> [25]

[4, 9]
[25]

📝 Notes

• There is no _.prototype.plant() function—the correct name is wrapper .plant(value) on a sequence object.
• .plant() returns a wrapper, not plain data—call .value() when you need the final array or object.
• The source wrapper is not mutated; planted wrappers are siblings that share the same queued actions.
• You can call .plant() multiple times from one pipeline to process different inputs in parallel.
• For a single transform on one dataset, rewriting _(data).map(fn) is often simpler than planting.
• Next in the series: .reverse() mutates the wrapped array in place.

💡 Best Practices