Event Emitter - Practice Coding Problems

Event Emitter - Problem

JavaScript Medium

Design an Event Emitter - Build a powerful event management system similar to Node.js EventEmitter or DOM Event Target!

Your task is to create an EventEmitter class that manages event subscriptions and emissions. This is a fundamental pattern used in many JavaScript frameworks and backend systems.

Key Requirements:

subscribe(eventName, callback) - Register listeners for events. Multiple callbacks can subscribe to the same event and will be called in subscription order. Returns an object with an unsubscribe() method.
emit(eventName, args) - Trigger all callbacks for an event with optional arguments. Returns an array of all callback results in subscription order, or empty array if no listeners.

Example: emitter.subscribe('click', () => 'Button clicked!') then emitter.emit('click') returns ['Button clicked!']

Input & Output

example_1.js — Basic Subscribe and Emit

$ Input: const emitter = new EventEmitter(); const sub = emitter.subscribe('click', () => 'Button clicked!'); const result = emitter.emit('click');

› Output: ['Button clicked!']

💡 Note: Single subscription returns array with one callback result

example_2.js — Multiple Subscriptions

$ Input: const emitter = new EventEmitter(); emitter.subscribe('test', (x) => x * 2); emitter.subscribe('test', (x) => x + 1); const result = emitter.emit('test', [5]);

› Output: [10, 6]

💡 Note: Multiple callbacks called in subscription order: 5*2=10, then 5+1=6

example_3.js — Unsubscribe

$ Input: const emitter = new EventEmitter(); const sub = emitter.subscribe('data', () => 'received'); sub.unsubscribe(); const result = emitter.emit('data');

› Output: []

💡 Note: After unsubscribing, no callbacks remain so emit returns empty array

Constraints

1 ≤ number of operations ≤ 10⁴
Event names are non-empty strings with length ≤ 100
Callback functions will not be referentially identical
Order matters: Callbacks must be called in subscription order

Visualization

Tap to expand

Understanding the Visualization

Hash Map Structure

Events stored as key-value pairs: event name → callback array

Subscribe Operation

Add callback to appropriate event array, return unsubscriber

Emit Operation

Lookup event O(1), execute all callbacks in order

Unsubscribe Operation

Remove specific callback from event array

Key Takeaway

🎯 Key Insight: Hash maps provide instant event lookup while arrays maintain callback order, making this the perfect data structure for event systems!

Asked in

f Meta 35 G Google 28 ⊞ Microsoft 22 a Amazon 18

The optimal solution uses a hash map to organize callbacks by event name, providing O(1) event lookup and maintaining subscription order. Each event name maps to an array of callbacks, allowing efficient emit operations that only process relevant subscribers.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Single Array)	O(n)	O(n)	Store all subscriptions in one array with event names
Hash Map Approach (Optimal)	O(k)	O(n)	Use hash map with event names as keys and callback arrays as values

Brute Force (Single Array) — Algorithm Steps

Store all subscriptions in one array with {eventName, callback, id}
For subscribe: push new subscription and return unsubscribe function
For emit: iterate through all subscriptions, filter by eventName, call callbacks
For unsubscribe: find subscription by id and remove from array

Visualization

Tap to expand

Step-by-Step Walkthrough

Add Subscription

Push new subscription to end of array

Emit Event

Scan entire array to find matching event names

Call Callbacks

Execute callbacks in order found

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef void* (*callback_t)(void** args, int argc);

typedef struct {
    int id;
    char* event_name;
    callback_t callback;
} subscription_t;

typedef struct {
    subscription_t* subscriptions;
    int count;
    int capacity;
    int next_id;
} event_emitter_t;

typedef struct {
    event_emitter_t* emitter;
    int subscription_id;
} unsubscriber_t;

event_emitter_t* create_event_emitter() {
    event_emitter_t* emitter = malloc(sizeof(event_emitter_t));
    emitter->subscriptions = malloc(10 * sizeof(subscription_t));
    emitter->count = 0;
    emitter->capacity = 10;
    emitter->next_id = 0;
    return emitter;
}

unsubscriber_t* subscribe(event_emitter_t* emitter, const char* event_name, callback_t callback) {
    if (emitter->count >= emitter->capacity) {
        emitter->capacity *= 2;
        emitter->subscriptions = realloc(emitter->subscriptions, emitter->capacity * sizeof(subscription_t));
    }
    
    int subscription_id = emitter->next_id++;
    subscription_t* sub = &emitter->subscriptions[emitter->count++];
    sub->id = subscription_id;
    sub->event_name = strdup(event_name);
    sub->callback = callback;
    
    unsubscriber_t* unsub = malloc(sizeof(unsubscriber_t));
    unsub->emitter = emitter;
    unsub->subscription_id = subscription_id;
    return unsub;
}

void** emit(event_emitter_t* emitter, const char* event_name, void** args, int argc, int* result_count) {
    void** results = malloc(emitter->count * sizeof(void*));
    *result_count = 0;
    
    for (int i = 0; i < emitter->count; i++) {
        if (strcmp(emitter->subscriptions[i].event_name, event_name) == 0) {
            results[*result_count] = emitter->subscriptions[i].callback(args, argc);
            (*result_count)++;
        }
    }
    
    return results;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each emit operation requires scanning all subscriptions to find matching events

✓ Linear Growth

Space Complexity

O(n)

Linear space for storing all subscriptions in single array

⚡ Linearithmic Space

42.3K Views

High Frequency

~15 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Single Array) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler