Lodash Wrapper .next() Method

What You’ll Learn

By the end of this tutorial, you’ll use wrapper .next() to walk lazy Lodash sequences one step at a time with { done, value } results.

What Is Wrapper .next()?

Wrapper .next() advances a lazy Lodash sequence one element at a time. Each call returns { done: boolean, value: any }—the same iterator shape used throughout JavaScript—so you can pull values manually instead of unwrapping everything with .value().

Use wrapper .next() for custom iteration over lazy chains—especially after filter or map when you want step-by-step control or deferred computation rather than materializing the full array upfront.

📝 Syntax

Call .next() on a wrapper with no arguments:

const wrapped = _([1, 2, 3]);
const step = wrapped.next();
// step -> { done: false, value: 1 }

Syntax Rules

• No arguments — each call advances the lazy sequence by one yielded value.
• Return shape — always { done, value }; check done before using value.
• When done is true — iteration finished; value is undefined.
• Lazy chains — works on wrappers with queued transforms (filter, map, etc.).
• vs bulk unwrap — prefer .value() when you need the entire result at once.

import _ from "lodash";

const wrapped = _([1, 2]);

console.log(wrapped.next());
// -> { done: false, value: 1 }

console.log(wrapped.next());
// -> { done: false, value: 2 }

console.log(wrapped.next());
// -> { done: true, value: undefined }

Examples Gallery

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

const wrapped = _([1, 2]);

console.log(wrapped.next());
// -> { done: false, value: 1 }

console.log(wrapped.next());
// -> { done: false, value: 2 }

console.log(wrapped.next());
// -> { done: true, value: undefined }

{ done: false, value: 1 }
{ done: false, value: 2 }
{ done: true, value: undefined }

const wrapped = _([1, 2, 3]);
const collected = [];
let result;

do {
  result = wrapped.next();
  if (!result.done) {
    collected.push(result.value);
  }
} while (!result.done);

console.log(collected);
// -> [1, 2, 3]

[1, 2, 3]

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

const evens = [];
let result;

while (true) {
  result = wrapped.next();
  if (result.done) break;
  evens.push(result.value);
}

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

[2, 4]

const wrapped = _([10, 20, 30]);
const doubled = [];
let result;

while (true) {
  result = wrapped.next();
  if (result.done) break;
  doubled.push(result.value * 2);
}

console.log(doubled);
// -> [20, 40, 60]

[20, 40, 60]

const data = [1, 2, 3];

const stepwise = [];
let w = _(data);
let r;
while (!(r = w.next()).done) {
  stepwise.push(r.value);
}

const bulk = _(data).value();

console.log(JSON.stringify(stepwise) === JSON.stringify(bulk));
// -> true

true

const numbers = [1, 2, 3];
const sum = 0;

// Simple array — use native iteration
for (const n of numbers) {
  // process n
}

// Lazy Lodash filter — .next() shines
const wrapped = _(numbers).filter(function (n) { return n > 1; });
// pull with wrapped.next()...

(no console output — pattern reference)

📝 Notes

• There is no _.prototype.next() function—the correct name is wrapper .next() on a sequence object.
• Always check result.done before using result.value—when done is true, value is undefined.
• Wrapper .next() follows the same iterator protocol shape as generators and native iterators.
• Especially useful after lazy filter or map when you want one element at a time.
• For everyday array iteration, native for...of is usually simpler unless you need Lodash lazy chains.
• Next in the series: .plant() clones a chain template onto new data.

💡 Best Practices