Lazy evaluation techniques in Javascript

Anton Ioffe - September 10th 2023 - 12 minutes read

In a world that values speed and efficiency, laziness might not seem like a worthwhile characteristic to pursue. But when it comes to Javascript, a world of programming filled with countless nuances and strategies, embracing laziness can unlock unforeseen capabilities and advantages, particularly in terms of performance and optimization. The technique we are referring to here is known as "Lazy Evaluation", a highly interesting aspect in Javascript that is sufficient to satiate your curiosity and ignite the code-enthusiast within you.

In this informed exploration, we aim to dissect multiple facets of lazy evaluation, from grasping fundamental concepts to seamless practical implementations, and finally diving into the depths of advanced aspects with a keen interest in performance-specific insights. This article is designed to satiate both, your knowledge cravings and your practical instincts, merging the theoretical aspects with hands-on techniques and concrete examples in order to foster a holistic and comprehensive understanding.

Supplemented by a comparative analysis with eager evaluation, this article will undoubtedly augment your skills to employ the appropriate evaluation strategy when the situation so demands. So, if you are yearning to make that shift from an eager beaver to a seasoned programmer who knows when to use a clever bout of laziness, our exploration into the realm of lazy evaluation in JavaScript is exactly what you need to delve into right now.

Understanding Lazy Evaluation in Javascript

Lazy evaluation, also known as call-by-need, is an evaluation strategy where expressions are only evaluated when their values are needed. This is in contrast to eager evaluation, also known as strict or call-by-value evaluation, where expressions are evaluated as soon as they are defined. While Javascript is primarily an eager evaluation language, it does accommodate certain lazy evaluation features we will explore in this article.

It is important to note the major differences between these two strategies. With eager evaluation, every operation in your code will execute, even if the result of some operations is not needed. On the contrary, lazy evaluation only executes an operation when its result is actually needed.

Pros and Cons of Lazy Evaluation in Javascript

As a developer, you might be wondering, "Why bother with lazy evaluation in Javascript when the language itself is designed to be eager?" There are several reasons you might want to consider.


  • Memory Efficiency: Lazy evaluation can be very memory-friendly as it only evaluates expressions when they are needed, thus it doesn’t allocate memory space until necessary.
  • Performance: With lazy evaluation, some parts of your program might never need to be evaluated, which can provide performance enhancements.
  • Infinite Data Structures: Lazy evaluation enables us to work with infinite data structures, as portions of the structure not being used are not evaluated.


  • Complexity: Implementing lazy evaluation can add complexity to your code. This can occur due to the additional work required to orchestrate when and where the evaluation should occur, potentially complicating code maintenance and readability.
  • Debugging: Debugging may get complicated due to deferred computations.
  • Unpredictable Time Lags: Lazy evaluation can create unpredictable time lags.

Code Examples: Eager vs Lazy Evaluation

To better appreciate the principles of lazy evaluation, let's contrast some examples of eager versus lazy evaluation.

// Eager Evaluation
function add(x, y) { 
    return x + y;
var eagerResult = add(1 + 2, 3 + 4);  // Returns 10

// Lazy Evaluation
function lazyAdd(x, y) {
    return function() { 
        return x() + y(); 
var x = function() { 
    return 1 + 2; 
var y = function() { 
    return 3 + 4; 
var lazyResult = lazyAdd(x, y);  // Stores a function to be called later
console.log(lazyResult());  // Logs 10 when evaluated

Common Mistakes

One common mistake developers often make regarding lazy evaluation in Javascript relates to the misunderstanding of how it works with infinite data structures.


// Function to generate infinite sequence of natural numbers
function* naturalNumbers() {
    let n = 1;
    while (true) {
        yield n++;
const array = [...naturalNumbers()];  // This will run indefinitely

Correction: Here's a correct way to consume infinite sequences with lazy evaluation. Instead of trying to store the entire sequence in memory, we create an iterator and generate values on demand:

const iterator = naturalNumbers();  // Create an iterator
console.log(;  // Logs 1
console.log(;  // Logs 2
// Consume the sequence as needed

This way, we're only generating and storing the numbers as we need them, thus not overburdening the memory or the processor.

Understanding when and how to properly use lazy evaluation in your Javascript code will open up new possibilities while helping you understand the tradeoffs associated with adding complexity to your code. However, it's essential to be cautious and understand how these principles apply within the context of your specific project for maximum efficiency.

Lazy Evaluation Techniques

Lazy evaluation, at its core, is the concept of delaying the computation of a function or an expression until its value is absolutely needed. Given JavaScript's eager evaluation stance, implementing lazy evaluation requires a shift in mindset and a careful consideration of coding practices.

The most common lazy evaluation technique in JavaScript is the short-circuit evaluation, leveraging JavaScript's logical AND (&&) and OR (||) operators.

Let’s dive into the details.

Short-Circuit Evaluation

In JavaScript, the && and || logical operators are not only used for logical conditions, but also for controlling the flow of the code with short-circuit evaluation.

Logical AND (&&)

The logical && operator short-circuits when it encounters the first "falsy" (false, 0, "", null, undefined, or NaN) value in an operation. Here's an example to illustrate this:

let x = 0 && alert('Hello World!');

In this case, the alert function is never executed because the && operator short-circuits due to x being a falsy value.

Logical OR (||)

On the other hand, the logical || operator short-circuits when it encounters the first "truthy" value (anything not considered falsy is truthy). Here's an improved example:

let x = 'Hello World!';
let y = x || alert('Hello World!');

Here, y receives the value of x because the || operator short-circuits at the first truthy operand, precluding the alert function from being invoked.

Common Mistakes

While lazy evaluation provides great flexibility in controlling the code flow, it is vital to avoid common mistakes which could lead to unexpected outputs.

Incorrect Checks

Often developers use if-else checks to validate variables. However, they might not remember that JavaScript treats 0, "", null, undefined and NaN as falsy values.


let x = "";
if (x) {
    console.log("It's true");
} else {
    console.log("It's false");

This will unexpectedly log "It's false" even though x is defined. The correct way to check for empty strings specifically is as follows:


let x = "";
if (x !== "") {
    console.log("It's true");
} else {
    console.log("It's false");

Now, console.log("It's true") will be executed because the !== "" check correctly validates that x is not an empty string.

Chaining Multiple Lazy Evaluations Together

While chaining multiple && or || together can provide more granular control, it can also lead to code that's hard to read and debug.


let x = `possibleValue1` || `possibleValue2` || `possibleValue3` || `possibleValue4` || `possibleValue5` || `possibleValue6`;

In this case, it's hard to tell which value x actually gets. The correct approach to deal with multiple values is:


function getFirstTruthyValue(params = []) {
    for (let i = 0; i < params.length; i++) {
        if (params[i]) {
            return params[i];
    return null;

let x = getFirstTruthyValue([`possibleValue1`, `possibleValue2`, `possibleValue3`, `possibleValue4`, `possibleValue5`, `possibleValue6`]);

Now the function, getFirstTruthyValue, iterates through each value and returns the first truthy value it finds, making the code more readable and maintainable.

Thought-provoking question: How might we enhance the efficiency of our code with other JavaScript features while still following a lazy evaluation approach? Can we strike a balance between using lazy evaluation and maintaining readable code? If so, what’s the best way to achieve that balance?

Practical Implementation of Lazy Evaluation via Examples

Lazy Evaluation with Lazy.js

Our first library is Lazy.js - a lightweight utility providing us with numerous functionalities akin to Underscore.js or Lodash. However, Lazy.js stands out for its “lazy” approach, which can be significantly more efficient.

Below is an example of how Lazy.js can be used:

const lazy = require('lazy.js');

let largeArray = new Array(1000000).fill().map(() => Math.random()); // Creates a large array

let sum = lazy(largeArray).filter(n => n % 2 === 0).take(5).reduce((sum, num) => sum + num, 0); // Lazy evaluation

With the use of lazy's version of filter, take, and reduce, we ensure our data is processed only when necessary. This dramatically improves performance and memory usage when working with large datasets.

Common Mistake: Uncontrolled Chain Calls

It's common to see unmanaged chains of calls when using Lazy.js, which potentially leads to superfluous computations.

Here's an example that oversteps the intended usage, marked as "Incorrect":

let sum = lazy(largeArray).filter(n => n % 2 === 0).take(5).reduce((sum, num) => sum + num, 0).count(); // Incorrect due to unmanageable computation

In the above code, after calculating the sum, the .count() function attempts to iterate over the whole chain, which includes all elements of the array. This can add hefty computational overhead especially when working with a large array.

Let's look at the correct way:

let filteredArray = lazy(largeArray).filter(n => n % 2 === 0).take(5);
let sum = filteredArray.reduce((sum, num) => sum + num, 0);
let count = filteredArray.size();

In this correct implementation, filteredArray is our lazy object. The take function restricts the scope of the following operations to the first five elements, optimizing resource use.

Javascript Generators: Built-In Lazy Evaluation

Javascript's built-in generators also offer lazy evaluation functionality. The key benefits of using generators are the ability to pause and continue execution, allowing you to process data on demand.

Here's an example:

function* genNumbers() {
    let i = 0;
    while (true) {
        yield i++;

let generator = genNumbers(); // Generator instance is created

console.log(; // Outputs 0 as it's calling genNumbers function for the first time
console.log(; // Outputs 1, calling genNumbers function for the second time

In the code above, the genNumbers() function is a generator giving us an infinite sequence of integers. Despite being 'infinite', the sequence management is memory-efficient due to its 'lazy' attributes.

Common Mistake: Forgetting the Yield Statement

Common mistakes associated with generators often involve forgetting to use the yield statement.

Below is an erroneous example:

function* genNumbers() {
  let i = 0;
  while(true) {

And followed by its correct version:

function* genNumbers() {
  let i = 0;
  while(true) {
    yield i++;

Without the yield statement, the function will execute indefinitely when invoked, causing a crash due to unrestrained memory usage. By using yield, we manage to control when we obtain the values, a perfect instance of lazy evaluation.

The Go-To Strategy

Whether it's through Lazy.js or Javascript generators, lazy evaluation serves as a powerful strategy to enhancing resource utilization by only processing what's needed at the right time. The examples and common mistakes provided in this post provide practical insight into the use of lazy evaluation in Javascript. Can you see opportunities in your coding where the principles of lazy evaluation might optimize performance?

Advanced Lazy Evaluation Concepts and Performance Insights

Lazy evaluation in JavaScript can be applied in more advanced ways beyond the simple examples often described. One such example is with lazy sequences and promises. This section takes a deeper dive into these advanced concepts and also the performance implications of using lazy evaluation.

Understanding Lazy Sequences

A lazy sequence is a sequence of computations that aren't run until their values are needed. They can potentially be infinite since values are computed when needed and not up front.

Consider this sample of a simple generator function:

function* naturalNumbers() {
    let num = 1;
    while (true)
        yield num++;

This function generates an infinite sequence of natural numbers. But instead of calculating all the numbers at once, which is impossible due to the infinite nature of the sequence, it calculates each number as they are needed.

A common mistake in JavaScript with sequences like this would be trying to generate all values at once:

for (let num of naturalNumbers()) {
    console.log(num); // runs indefinitely

The correct approach should involve setting a limit:

let numbers = naturalNumbers();
for(let i=0; i<100; i++){

This ensures only the first 100 values are generated and printed, demonstrating the power of lazy sequences.

Investigating Promises

Promises can also be seen as a form of lazy evaluation. When you create a Promise, the computation is not performed until .then() is called on the promise.


let promise = new Promise((resolve, reject) => {
    resolve('Data fetched');
console.log('Promise created');
promise.then(data => console.log(data));

The 'Data fetched' is not logged until .then() is invoked on the promise, thus demonstrating the lazy nature of promises.

Performance Considerations

Is lazy evaluation faster? Will it make your JavaScript run more efficiently? The extensive answer is, it depends. As lazy evaluation delays computation, it avoids unnecessary computations and hence, in scenarios where not all data is required, it can be faster.

However, lazy evaluation can add some overhead because of the need to check if computation is needed every time data is accessed. Therefore, if all data is required, then strict evaluation may outperform lazy evaluation.

A common mistake around performance considerations is using lazy evaluation indiscriminately. Using lazy evaluation in scenarios where all data is required can actually make the code slower, due to the overhead of managing the lazy computation.

Relationship with Strictness

Strict evaluation is the opposite of lazy evaluation. In a strictly evaluated language, functions always evaluate their arguments before invoking. In contrast, as we've seen, JavaScript's evaluation strategy is non-strict, hence making lazy evaluation possible.

But, strictly evaluated code can coexist with lazy evaluated code. That's the reason you can, in JavaScript, use a mix of strict and lazy evaluation according to what suits your performance and architecture needs. Just be wary of when each evaluation makes sense.

What about memory considerations when using lazy evaluation on large sequences? Lazy evaluation with large sequences can be memory-intensive due to the overhead of maintaining thunks (delayed computations) for later. On the other hand, strict evaluation with such sequences would be computationally expensive as it would require evaluating the entire sequence upfront. Thus, choosing between evaluation strategies is highly dependent on the context and the specific requirements of your project.

In closing, lazy evaluation can certainly be a powerful concept to add to your JavaScript toolbelt. While it's not a silver bullet, it does help create more efficient and modular code when used in the right context. It can also help avoid unnecessary computations in certain scenarios, but misuse can lead to memory or performance penalties. Knowing when to use it and what it costs is the key to leveraging it effectively.


The article delves into the various nuances that surround the concept of Lazy Evaluation in Javascript and how it can significantly contribute to performance optimization and efficient memory utilization. With detailed code examples, the write-up underscores the principles of Lazy evaluation and juxtaposes them against Eager evaluation. Towards the end, it dives into the potential of lazy evaluation techniques including short-circuit evaluation as well as advanced concepts like lazy sequences and promises. Critical considerations including memory and performance are examined in order to better appreciate the use of lazy evaluation in different contexts.

Key takeaways include the understanding of when and how lazy evaluation can be best utilized to bring on memory efficiency, performance enhancement, and the ability to handle infinite data structures. However, the article also cautions about using it indiscriminately due to potential challenges like debugging complexity and unpredictable time lags and emphasizes the importance of careful thought around implementation especially for more advanced use cases.

Your challenging task is to analyze your current JavaScript codebase and identify areas where lazy evaluation techniques can be applied to increase performance and maintainability. Pay specific attention to any sections of your code where you’re dealing with large data structures or computations that could be delayed until necessary. Implement lazy evaluation in these areas and document any changes in performance or efficiency. Also, consider the trade-offs for implementing these changes in terms of code readability and complexity.

Don't Get Left Behind:
The Top 5 Career-Ending Mistakes Software Developers Make
FREE Cheat Sheet for Software Developers