Questions
3 of 38
1What is the Iterator Protocol in JavaScript? What two things must an object implement to be a valid iterator?
2What is the difference between an iterable and an iterator? Can something be both?
3What built-in JavaScript data structures are iterable by default? How does for...of work under the hood with them?
4What does Symbol.iterator do? How would you make a plain object iterable from scratch?
5What is a 'lazy' iterator and why is it important for performance? Give a practical example.
6How would you implement an infinite iterator (e.g., an infinite counter)? How do you safely consume it?
7What happens if you forget to return { done: true } in a custom iterator? What are the consequences?
8How would you implement a reusable iterable (one that can be iterated multiple times)?
9Can you chain or compose custom iterators? Implement a map and filter for a custom iterator without converting to an array.
10What is a generator function? How is it different from a regular function in terms of execution flow?
11Explain what yield does. What does calling .next() return before and after a yield?
12What is the difference between yield and return inside a generator?
13What does yield* do? How is it different from a regular yield?
14Can you pass a value into a generator using .next(value)? How does that work and what is the practical use case?
15Explain generator.return(value) and generator.throw(error). When would you use each in production?
16What happens to a try/finally block inside a generator when .return() is called externally?
17How do generators handle errors? How does .throw() interact with try/catch inside a generator?
18Are generators lazy? How do they differ from eager evaluation with arrays in terms of memory and performance?
19What is the difference between a regular iterator and an async iterator? What protocol does an async iterator follow?
20What does Symbol.asyncIterator do? How does for await...of use it?
21Implement an async generator that fetches paginated API data, yielding one page at a time:
22What are the pitfalls of using for await...of with an async generator that makes network calls? How do you handle errors and cancellation?
23How would you implement a readable stream as an async iterable in Node.js?
24How would you use a generator to implement redux-saga-style side effect management? What makes generators a good fit for this?
25How can generators be used to implement coroutines or cooperative multitasking in JavaScript?
26Implement a take(n) utility that takes the first n values from any iterable — including infinite ones:
27When would you choose a generator over returning an array? What are the memory trade-offs?
28In a data pipeline processing millions of records, how would you use generators to avoid loading everything into memory?
29What are the debugging challenges with generators (e.g., in stack traces and async flows)? How do you mitigate them?
30How do generators compose? Implement a pipeline of generator-based transformations (like RxJS operators but synchronous).
31What are the limitations of generators? What problems are they not a good fit for?
32What are Iterator Helpers (.map(), .filter(), .take(), .drop() on iterators natively)? What stage are they at in the TC39 proposal pipeline?
33How does Array.from() use the iterator protocol? What's the difference between passing an iterable vs an array-like object?
34How do Map, Set, Array, and String expose their iterators? Are they the same object or different?
35What is the difference between map.keys(), map.values(), and map.entries()? What do they return?
36How does destructuring and spread (...) use the iterator protocol internally?
37How would you implement Promise-based async/await using generators and a runner function? (This is essentially how Babel transpiled async/await early on.)
38How would you use a generator to implement a tree traversal (DFS) without recursion stack concerns?
javascriptjavascript
Basics
Engine
JIT
V8
Event Loop and Runtime
Concurrency and Threading
Bytecode and Parsing
Execution Context
Data Types
Functions
String Operations
Array Operations
this
Call Apply Bind
Closure
Objects
ES6 Classes
Events
ES6
Promises
Iterator and Generator
Error Handling
Web Workers
PWA
Web Sockets
Web Assembly
Garbage Collector
Modules
Browser APIS
Functional Programming
Currying
Higher Order Functions
Memoisation
Security
Code
Polyfills
03 / 38

What built-in JavaScript data structures are iterable by default? How does for...of work under the hood with them?

Array, String, Map, Set, TypedArray, arguments, and NodeList are iterable by default. for...of calls the [Symbol.iterator]() method and loops over the value property of each next() result until done is true.

Under the hood, for...of obtains the iterator by calling the object's [Symbol.iterator]() method, then repeatedly calls the iterator's next() method, storing the value property in the loop variable and stopping when done is true. Example: const arr = [1,2,3]; for (const v of arr) { console.log(v); }

Difficulty: 5/10
Topics: iterable protocols, built-in iterables, for...of mechanics

Scenario Questions

0-2 years experience
  1. 1

    You need to loop over the keys of a plain object and also over an array of numbers. Which built‑in structures can you use directly with a for...of loop, and what would happen if you tried it on a plain object?

  2. 2

    Write a short snippet that uses for...of to iterate over a Map and logs each key/value pair. What does the loop receive on each iteration?

  3. 3

    If you have a Set containing duplicate values, how does for...of iterate over it compared to a regular array?

2-5 years experience
  1. 1

    Your team added a feature that processes user‑submitted data stored in a TypedArray. The code uses for...of, but performance seems slower than a classic for loop. Explain why this might be and how you would decide which loop to keep.

  2. 2

    During a bug hunt you notice that a for...of loop over an arguments object yields nothing. Why does this happen, and how would you fix the iteration without converting to an array?

  3. 3

    We need to refactor a utility that currently uses for...in on an array to a for...of. What edge cases should you watch for, and how does the iterator protocol affect the change?

5-8 years experience
  1. 1

    Design a library that accepts any iterable (Array, Map, Set, String, TypedArray, etc.) and applies a transformation function lazily. How would you leverage the built‑in iterator protocol and for...of internally, and what performance considerations arise at scale?

  2. 2

    Our codebase has a custom collection class that currently implements Symbol.iterator incorrectly, causing for...of to skip elements. How would you diagnose the issue and ensure compatibility with all built‑in iterables?

  3. 3

    When streaming large data from a server, we want to process chunks using for...of over a ReadableStream. Explain how the async iterator works under the hood and what trade‑offs exist compared to event callbacks.

8+ years experience
  1. 1

    We are migrating a legacy monolith that heavily uses for...in on array‑like objects to a modern codebase that prefers for...of and async iterables. What architectural guidelines would you set to avoid subtle bugs across teams, and how would you phase the migration?

  2. 2

    A cross‑team initiative aims to standardize data handling by exposing all collections as iterables, including database cursors and in‑memory caches. What design patterns and contract decisions would you propose to ensure consistent behavior of for...of across heterogeneous sources?

  3. 3

    Consider a high‑throughput microservice that processes millions of events per second using for...of over a custom circular buffer. How would you evaluate the impact of the iterator protocol on GC pressure and latency, and what alternatives might you recommend?

Follow-up Questions

  • ❓Can you walk me through what happens internally when a for...of loop starts iterating over a Set?
  • ❓How does defining or overriding Symbol.iterator on an object change its behavior in a for...of loop?
  • ❓What would happen if an iterator's next method returned a non‑object or omitted the done property?