Unlock 37% Faster Lo‑Dash Performance with Lazy Evaluation and Pipelining

Lazy Evaluation

I used to think libraries like Lo‑Dash were already as fast as possible, but further speed gains are achievable by abandoning micro‑optimizations of each iteration and instead reducing the number of iterations needed. For a typical loop you first obtain the array length and then repeat operation() N times.

Optimizing the execution time of operation() is often difficult and yields limited gains, whereas optimizing getLength() —making it return a smaller number—reduces how many loop cycles run, because fewer elements need processing.

This is the core idea of Lo‑Dash’s lazy evaluation: reduce the number of cycles rather than the time per cycle.

Example: Filtering Gems

Consider an array gems containing eight objects with name and price. The helper priceLt(x) returns all elements whose price is lower than x. We want the first three gems priced under $10.

With strict (eager) Lo‑Dash, the library filters all eight gems and then returns the first three results, processing every element.

Using lazy evaluation, the chain stops as soon as three qualifying items are found, processing only the minimum required elements. The benchmark shows a 37.5 % performance improvement.

Large‑Scale Example

In a second benchmark, map and filter are applied to 99,999 elements, but only a subset of 10,000 is needed for the final result. Because lazy evaluation processes just the needed subset, the speedup is dramatic (the exact numbers are shown in the accompanying chart).

Pipelining

Lazy evaluation also enables "pipelining": intermediate arrays are not created during chained method execution. Instead, each element flows through the entire chain of operations before the next element is handled. The diagram compares regular Lo‑Dash (which creates temporary arrays) with the lazy version that avoids them.

Eliminating temporary arrays yields significant performance gains, especially when the source array is large and memory access is costly.

Deferred Execution

Lazy evaluation works together with deferred execution. A chain is built but not evaluated until .value() is called explicitly (or implicitly). This allows a query to be prepared in advance and executed later with the freshest data, sometimes further reducing execution time.

Wrap Up

Lazy evaluation is not a new concept; it appears in many libraries such as LINQ and Lazy.js. Lo‑Dash’s advantage is that it provides this power while keeping the familiar Underscore API, so developers can upgrade without learning a new library or rewriting code.

Even if you decide not to adopt Lo‑Dash, the article encourages you to look beyond micro‑benchmarks and consider algorithmic improvements when you encounter performance bottlenecks.