Problem Description

You need to create an EventEmitter class that manages event subscriptions and emissions. This class allows you to register callback functions for specific events and trigger those callbacks when the event is emitted.

The class must implement two methods:

1. subscribe(eventName, callback)

• Takes an event name (string) and a callback function as parameters
• Registers the callback to be executed when the specified event is emitted
• Multiple callbacks can be registered for the same event
• Returns a subscription object with an unsubscribe() method that:
  • Removes the callback from the event's subscription list
  • Returns undefined when called

2. emit(eventName, args)

• Takes an event name (string) and an optional array of arguments
• Executes all callbacks registered for that event in the order they were subscribed
• Passes the provided arguments to each callback using spread syntax
• Returns an array containing the results from all callback executions
• If no callbacks are registered for the event, returns an empty array

Key Requirements:

• Callbacks for the same event must execute in subscription order
• Each callback receives the arguments passed to emit
• The unsubscribe method should only remove the specific callback it was created for
• Multiple subscriptions to the same event should all work independently

Example Usage:

const emitter = new EventEmitter();
function onClickCallback() { return 99; }
const sub = emitter.subscribe('onClick', onClickCallback);
emitter.emit('onClick'); // Returns [99]
sub.unsubscribe(); // Returns undefined
emitter.emit('onClick'); // Returns []

Intuition

The core challenge is managing multiple callbacks for different events while maintaining their order and allowing individual unsubscription. Let's think through what data structure would work best.

We need to store callbacks grouped by event names. A Map is perfect for this - it gives us O(1) lookup by event name. For each event, we need to store multiple callbacks. While an array seems natural for maintaining order, it has a problem: removing a specific callback requires O(n) search time and array manipulation.

Here's the key insight: JavaScript's Set maintains insertion order (since ES2015) while providing O(1) deletion. This gives us the best of both worlds - we can maintain subscription order and efficiently remove specific callbacks.

The structure becomes: Map<eventName, Set<callbacks>>.

For the subscribe method, we add the callback to the event's Set. If the event doesn't exist yet, we create a new Set first. The clever part is returning an object with an unsubscribe method that captures the specific callback in its closure. This way, each subscription has its own unsubscribe function that knows exactly which callback to remove.

For the emit method, we retrieve the Set of callbacks for the given event. Since Sets are iterable and maintain insertion order, we can spread it into an array [...callbacks] and map over it to execute each callback with the provided arguments. The spread operator ...args ensures each callback receives the arguments as individual parameters rather than as an array.

The beauty of using Set is that it automatically handles duplicate prevention (though the problem states callbacks won't be referentially identical) and gives us efficient operations. The delete method on Set returns a boolean, but we don't need to track whether the deletion was successful - we just call it when unsubscribe is invoked.

Solution Approach

Let's implement the EventEmitter class step by step:

1. Class Structure and Data Storage

class EventEmitter {
    private d: Map<string, Set<Callback>> = new Map();
}

We use a Map called d to store our events. Each key is an event name (string), and each value is a Set of callback functions. This gives us O(1) access to any event's callbacks and O(1) addition/removal of callbacks.

2. Subscribe Method Implementation

subscribe(eventName: string, callback: Callback): Subscription {
    this.d.set(eventName, (this.d.get(eventName) || new Set()).add(callback));
    return {
        unsubscribe: () => {
            this.d.get(eventName)?.delete(callback);
        },
    };
}

The subscription logic works as follows:

• this.d.get(eventName) || new Set() - Get the existing Set of callbacks for this event, or create a new Set if this is the first subscription
• .add(callback) - Add the new callback to the Set (Set's add method returns the Set itself, enabling chaining)
• this.d.set(eventName, ...) - Store the updated Set back in the Map

The returned subscription object contains an unsubscribe method that:

• Uses optional chaining ?. to safely access the Set (in case it was somehow removed)
• Calls delete(callback) to remove the specific callback from the Set
• The closure captures both eventName and callback, so each subscription knows exactly what to unsubscribe

3. Emit Method Implementation

emit(eventName: string, args: any[] = []): any {
    const callbacks = this.d.get(eventName);
    if (!callbacks) {
        return [];
    }
    return [...callbacks].map(callback => callback(...args));
}

The emission process:

• Retrieve the Set of callbacks for the given event name
• If no callbacks exist (event was never subscribed to or all were unsubscribed), return an empty array
• Convert the Set to an array using spread syntax [...callbacks] to maintain insertion order
• Map over each callback, executing it with the provided arguments using spread ...args
• Collect and return all the callback return values in an array

Type Definitions

type Callback = (...args: any[]) => any;
type Subscription = {
    unsubscribe: () => void;
};

These types ensure type safety:

• Callback accepts any number of arguments and can return anything
• Subscription defines the shape of the object returned by subscribe

This implementation efficiently handles all requirements: maintains subscription order, allows multiple listeners per event, supports individual unsubscription, and properly passes arguments to callbacks.

Example Walkthrough

Let's walk through a concrete example to see how the EventEmitter works internally:

const emitter = new EventEmitter();

// Step 1: Subscribe first callback to 'click' event
const callback1 = (x) => x * 2;
const sub1 = emitter.subscribe('click', callback1);
// Internal state: Map { 'click' => Set { callback1 } }

// Step 2: Subscribe second callback to same event
const callback2 = (x) => x + 10;
const sub2 = emitter.subscribe('click', callback2);
// Internal state: Map { 'click' => Set { callback1, callback2 } }
// Note: Set maintains insertion order

// Step 3: Subscribe to a different event
const callback3 = () => 'hello';
const sub3 = emitter.subscribe('hover', callback3);
// Internal state: Map { 
//   'click' => Set { callback1, callback2 },
//   'hover' => Set { callback3 }
// }

// Step 4: Emit 'click' event with argument [5]
const result1 = emitter.emit('click', [5]);
// Process:
// 1. Get Set for 'click': Set { callback1, callback2 }
// 2. Convert to array: [callback1, callback2] (preserves order)
// 3. Execute each: callback1(5) = 10, callback2(5) = 15
// Returns: [10, 15]

// Step 5: Unsubscribe first callback
sub1.unsubscribe();
// The closure remembers 'click' and callback1
// Executes: this.d.get('click').delete(callback1)
// Internal state: Map { 
//   'click' => Set { callback2 },
//   'hover' => Set { callback3 }
// }

// Step 6: Emit 'click' again
const result2 = emitter.emit('click', [5]);
// Only callback2 remains in the Set
// Returns: [15]

// Step 7: Emit event with no subscribers
const result3 = emitter.emit('missing', []);
// No Set exists for 'missing'
// Returns: []

This example demonstrates:

• How the Map stores Sets of callbacks for each event name
• How Set maintains insertion order for callbacks
• How the unsubscribe closure captures specific callback references
• How emit converts the Set to an array while preserving order
• How the solution handles edge cases like non-existent events

Solution Implementation

Time and Space Complexity

Time Complexity:

• subscribe(eventName, callback): O(1) amortized

  • Map.get() operation: O(1) average case
  • Set.add() operation: O(1) average case
  • Creating the subscription object with unsubscribe function: O(1)

• unsubscribe(): O(1) amortized

  • Map.get() operation: O(1) average case
  • Set.delete() operation: O(1) average case

• emit(eventName, args): O(n) where n is the number of callbacks subscribed to the event

  • Map.get() operation: O(1) average case
  • Spreading the Set into an array [...callbacks]: O(n)
  • Mapping over callbacks and executing each: O(n)
  • Each callback execution time depends on the callback implementation (not counted here)

Space Complexity:

• Overall EventEmitter instance: O(m * k) where m is the number of unique event names and k is the average number of callbacks per event

  • The Map stores up to m event names
  • Each event name maps to a Set containing its callbacks

• subscribe(eventName, callback): O(1) additional space

  • May create a new Set if the event doesn't exist yet: O(1)
  • Adds one callback reference to the Set: O(1)
  • Creates a subscription object: O(1)

• emit(eventName, args): O(n) additional space where n is the number of callbacks for the event

  • Creates a new array from the Set: O(n)
  • Creates a result array from map operation: O(n)
  • The args array is passed by reference (not copied)

• unsubscribe(): O(1) additional space

  • Only removes a reference, no additional space allocated

Common Pitfalls

1. Maintaining Insertion Order with Sets

Pitfall: The Python implementation uses a Set to store callbacks, but standard Python sets don't guarantee insertion order preservation (though since Python 3.7+, dict insertion order is preserved, sets still don't officially guarantee this). This violates the requirement that callbacks must execute in the order they were subscribed.

Example of the problem:

# If callbacks aren't executed in subscription order:
emitter = EventEmitter()
results = []
emitter.subscribe('test', lambda: results.append(1))
emitter.subscribe('test', lambda: results.append(2))
emitter.subscribe('test', lambda: results.append(3))
emitter.emit('test')
# Expected: results = [1, 2, 3]
# Possible with Set: results could be [2, 1, 3] or any order

Solution: Use a list or OrderedDict to maintain insertion order:

from collections import OrderedDict

class EventEmitter:
    def __init__(self):
        # Use dict with callback as key and True as value to maintain order
        self.events = {}  # eventName -> OrderedDict of callbacks
  
    def subscribe(self, eventName, callback):
        if eventName not in self.events:
            self.events[eventName] = OrderedDict()
      
        # Use callback as key to enable O(1) removal
        self.events[eventName][callback] = True
      
        def unsubscribe():
            if eventName in self.events and callback in self.events[eventName]:
                del self.events[eventName][callback]
                if not self.events[eventName]:
                    del self.events[eventName]
      
        return type('Subscription', (), {'unsubscribe': unsubscribe})()
  
    def emit(self, eventName, args=None):
        if args is None:
            args = []
      
        if eventName not in self.events:
            return []
      
        # Callbacks execute in insertion order
        return [callback(*args) for callback in self.events[eventName].keys()]

2. Multiple Subscriptions of the Same Callback

Pitfall: Using a Set or dict with the callback as a key prevents subscribing the same callback function multiple times to the same event. This might be desired behavior in some cases.

Example of the problem:

def onClick():
    return 1

emitter = EventEmitter()
sub1 = emitter.subscribe('click', onClick)
sub2 = emitter.subscribe('click', onClick)  # This won't add a second subscription
result = emitter.emit('click')
# Expected if allowing duplicates: [1, 1]
# Actual with Set/dict: [1]

Solution: If duplicate subscriptions are needed, use a list with unique subscription IDs:

class EventEmitter:
    def __init__(self):
        self.events = {}  # eventName -> list of (id, callback) tuples
        self.next_id = 0
  
    def subscribe(self, eventName, callback):
        if eventName not in self.events:
            self.events[eventName] = []
      
        subscription_id = self.next_id
        self.next_id += 1
        self.events[eventName].append((subscription_id, callback))
      
        def unsubscribe():
            if eventName in self.events:
                self.events[eventName] = [
                    (sid, cb) for sid, cb in self.events[eventName] 
                    if sid != subscription_id
                ]
                if not self.events[eventName]:
                    del self.events[eventName]
      
        return type('Subscription', (), {'unsubscribe': unsubscribe})()
  
    def emit(self, eventName, args=None):
        if args is None:
            args = []
      
        if eventName not in self.events:
            return []
      
        return [callback(*args) for _, callback in self.events[eventName]]

3. Modifying the Subscription List During Emission

Pitfall: If a callback unsubscribes itself or other callbacks during execution, iterating over the original collection can cause issues.

Example of the problem:

emitter = EventEmitter()
sub = None

def callback1():
    sub.unsubscribe()  # Unsubscribes itself during execution
    return 1

def callback2():
    return 2

sub = emitter.subscribe('test', callback1)
emitter.subscribe('test', callback2)
result = emitter.emit('test')  # Might cause iteration issues

Solution: Create a copy of the callbacks list before iteration:

def emit(self, eventName, args=None):
    if args is None:
        args = []
  
    if eventName not in self.events:
        return []
  
    # Create a snapshot of callbacks to avoid modification during iteration
    callbacks_snapshot = list(self.events[eventName].keys())
    return [callback(*args) for callback in callbacks_snapshot if callback in self.events.get(eventName, {})]