Practical closure use cases in Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a closure in JavaScript?

A closure is a function that remembers and can access variables from its outer (enclosing) function scope even after the outer function has finished executing.

intermediate

How do closures help in data privacy?

Closures allow you to create private variables by keeping variables inside a function scope and exposing only specific functions that can access or modify those variables.

intermediate

Explain how closures are used in event handlers.

Closures let event handlers remember the environment where they were created, so they can access variables from that scope when the event happens, even if the outer function has finished.

intermediate

What is a common use case of closures in function factories?

Function factories use closures to create customized functions that remember specific data, like creating a multiplier function that remembers the multiplier value.

advanced

How do closures help in implementing memoization?

Closures store a cache of previous results inside the function scope, allowing the function to return cached results for the same inputs without recalculating.

What does a closure allow a function to do?

A Access variables from its outer function even after the outer function has returned

B Change the global variables directly

C Run only once and then disappear

D Prevent any variable access outside its own scope

Closures keep access to variables from their outer function scope even after that function has finished.

Which of these is a practical use of closures?

A Making synchronous HTTP requests

B Changing HTML styles directly

C Loading external scripts

D Creating private variables

Closures are commonly used to create private variables that cannot be accessed from outside.

How do closures help in event listeners?

A They prevent event listeners from running multiple times

B They allow event listeners to remember variables from the scope where they were created

C They automatically remove event listeners after one use

D They make event listeners run faster by caching DOM elements

Closures let event listeners access variables from their creation scope even after that scope has ended.

What is memoization in relation to closures?

A Creating multiple copies of a function

B Making a function run only once

C Storing previous function results inside a closure to avoid repeated calculations

D Using closures to hide global variables

Memoization uses closures to keep a cache of results for faster repeated calls.

Which example best shows a closure?

A A function returning another function that uses variables from the first function

B A function that modifies a global variable

C A function that only uses local variables

D A function that calls itself recursively

A closure happens when a function returns another function that accesses variables from the outer function.

Describe three practical use cases of closures in JavaScript and explain why closures are useful in each case.

Think about how closures keep variables alive and hidden.

Explain how closures enable memoization and why this improves performance.

Consider how remembering past work saves time.

Practice

1. What is the main benefit of using closures in JavaScript?

easy

A. They make code run faster by optimizing loops.

B. They allow functions to remember variables from their creation context.

C. They automatically free memory when variables are no longer used.

D. They let you write code without using functions.

Solution

1. Step 1: Understand closure concept

   Closures let a function remember variables from the place where it was created, even after that place has finished running.

2. Step 2: Compare options

   Only They allow functions to remember variables from their creation context. correctly describes this key feature. Other options describe unrelated or incorrect ideas.

3. Final Answer:

   They allow functions to remember variables from their creation context. -> Option B

4. Quick Check:

   Closure = Remember variables [OK]

Hint: Closures remember variables where functions are made [OK]

Common Mistakes:

• Thinking closures speed up code automatically
• Confusing closures with garbage collection
• Believing closures remove the need for functions

2. Which of the following is the correct syntax to create a closure that keeps a private counter?

easy

A. function counter() { return count++; let count = 0; }

B. function counter() { var count = 0; count++; return count; }

C. let count = 0; function counter() { count++; return count; }

D. function counter() { let count = 0; return function() { count++; return count; }; }

Solution

1. Step 1: Identify closure pattern

   function counter() { let count = 0; return function() { count++; return count; }; } defines a function that returns another function which accesses the variable 'count' inside its scope, creating a closure.

2. Step 2: Check other options

   function counter() { var count = 0; count++; return count; } increments count but does not return a function, so no closure. let count = 0; function counter() { count++; return count; } uses a global variable, not private. function counter() { return count++; let count = 0; } has syntax error (return before variable declaration).

3. Final Answer:

   function counter() { let count = 0; return function() { count++; return count; }; } -> Option D

4. Quick Check:

   Closure = function inside function with private variable [OK]

Hint: Closure needs inner function accessing outer variable [OK]

Common Mistakes:

• Returning value instead of function for closure
• Using global variables instead of private ones
• Placing return before variable declaration

3. What will be the output of the following code?

function makeAdder(x) {
  return function(y) {
    return x + y;
  };
}
const add5 = makeAdder(5);
console.log(add5(3));

medium

A. 53

B. NaN

C. 8

D. undefined

Solution

1. Step 1: Understand makeAdder function

   makeAdder returns a function that adds its argument y to x, which is remembered via closure.

2. Step 2: Calculate add5(3)

   add5 is makeAdder(5), so x=5. Calling add5(3) returns 5 + 3 = 8.

3. Final Answer:

   8 -> Option C

4. Quick Check:

   Closure adds remembered x to y = 8 [OK]

Hint: Closure remembers x=5, adds y=3 to get 8 [OK]

Common Mistakes:

• Concatenating numbers as strings
• Forgetting closure remembers x
• Expecting undefined or NaN

4. Find the error in this closure example:

function createFuncs() {
  let funcs = [];
  for (var i = 0; i < 3; i++) {
    funcs.push(function() { return i; });
  }
  return funcs;
}
const functions = createFuncs();
console.log(functions[0]());

medium

A. All functions return 3 instead of 0, 1, 2 due to var scoping.

B. Syntax error because of missing semicolons.

C. functions array is empty because push is not called.

D. The code runs correctly and prints 0.

Solution

1. Step 1: Analyze loop variable scope

   Using var for i means one shared variable. All functions capture the same i, which after loop ends is 3.

2. Step 2: Understand closure effect

   Each function returns i, but i is 3 at call time, so all return 3, not 0,1,2.

3. Final Answer:

   All functions return 3 instead of 0, 1, 2 due to var scoping. -> Option A

4. Quick Check:

   var in loop causes shared i = 3 [OK]

Hint: var in loop shares variable; use let for block scope [OK]

Common Mistakes:

• Assuming each function captures separate i
• Thinking semicolons cause error
• Expecting functions array to be empty

5. How can you modify this code to create an array of functions each returning its own index?

function createFuncs() {
  let funcs = [];
  for (var i = 0; i < 3; i++) {
    funcs.push(function() { return i; });
  }
  return funcs;
}
const functions = createFuncs();
console.log(functions[0](), functions[1](), functions[2]());

hard

A. Replace var with let in the for loop declaration.

B. Declare i with var but add a closure with an IIFE inside the loop.

C. Use a global variable instead of i.

D. No change needed; code works as is.

Solution

1. Step 1: Understand problem with var

   var is function-scoped, so all functions share same i, which ends at 3.

2. Step 2: Fix with let for block scope

   Replacing var with let makes i block-scoped, so each iteration has its own i captured by closure.

3. Final Answer:

   Replace var with let in the for loop declaration. -> Option A

4. Quick Check:

   let creates separate i per loop iteration [OK]

Hint: Use let in loops to create separate closure variables [OK]

Common Mistakes:

• Using global variables causing shared state
• Thinking IIFE is only solution
• Believing code works without changes