Course contentsShow
← JavaScript
Lesson 2047 of 2,72342. Iteration Protocols Deep DiveFree lesson

Async Generator Use Case: Event Streams

Learn how async generators can model event streams, yielding events as they occur over time.

Async Generator Use Case: Event Streams

You'll learn: How async generators naturally model event streams by yielding events as they occur over time.

The Core Idea

Event streams — like user clicks, websocket messages, or sensor readings — arrive asynchronously and unpredictably over time. Async generators are perfect for this pattern because they let you yield each event as it happens, creating an iterable stream that consumers can process with for-await-of.

Think of it like a conveyor belt at a factory: items (events) arrive at unpredictable intervals, but workers (your code) can process them one-by-one in order, waiting when necessary.

How It Works

Instead of registering event listeners with callbacks (which scatter logic), you centralize event handling in an async generator that yields each event:

async function* listenToClicks(button) {
  const clickQueue = [];
  let resolver;
  
  button.addEventListener('click', (event) => {
    if (resolver) {
      resolver(event);
      resolver = null;
    } else {
      clickQueue.push(event);
    }
  });
  
  while (true) {
    if (clickQueue.length > 0) {
      yield clickQueue.shift();
    } else {
      yield new Promise(resolve => { resolver = resolve; });
    }
  }
}

// Consume the stream
const button = document.querySelector('#myButton');
for await (const clickEvent of listenToClicks(button)) {
  console.log('Button clicked at', clickEvent.timeStamp);
  if (someCondition) break; // Stop listening
}

This transforms push-based events into pull-based iteration, giving you control flow back.

Why This Matters

Async generators turn chaotic event streams into sequential, manageable flows. You can use loops, breaks, and error handling naturally instead of callback spaghetti.

Key Takeaway: Async generators excel at modeling event streams, transforming unpredictable push-based events into clean, iterable sequences you can consume with for-await-of.