Easy

Memoize II

Prompt

In the first part of the Memoize challenge, you built a function that caches results to avoid redundant computation. But how do you actually prove it's faster?

Your task is to use console.time() and console.timeEnd() to measure the execution time of a memoized function across multiple calls and demonstrate the performance benefit.

Given the memoize function and an expensive square function (that uses nested loops instead of n * n), measure how long each call takes and observe the difference between the first call and subsequent cached calls.

Playground

Solution

Explanation

How do you measure performance in JavaScript?

JavaScript gives us a simple built-in stopwatch: console.time() and console.timeEnd().

You start the stopwatch with a label, run some code, and then stop the stopwatch with the same label. The browser prints how many milliseconds elapsed.

console.time('my-operation');
// ... some code runs here ...
console.timeEnd('my-operation');
// Output: my-operation: 12.34ms

What does this tell us about memoization?

When you run the solution above, you'll see something like:

Call 1: 2.5ms     ← Actually computed (cache miss)
Call 2: 0.01ms    ← Returned from cache (cache hit)
Call 3: 0.01ms    ← Returned from cache (cache hit)

The first call takes real time because the square function actually runs its nested loops. The second and third calls are nearly instant because the memoized function finds the result in the cache and returns it without ever running square again.

This is the whole point of memoization: trade memory for speed. You store results so you never compute the same thing twice.