Map.prototype.clear()

map.clear()

Returns: undefined · Added in vES6 · Updated March 13, 2026 · Map and Set

javascript map clear cleanup

The Map.prototype.clear() method removes all key-value pairs from a Map object, instantly resetting it to an empty state. This is useful when you need to reset a cache, clear accumulated data, or reuse a Map instance for a new set of entries. The method operates in-place and returns undefined.

Syntax

map.clear()

Parameters

This method takes no parameters.

Return Value

Returns undefined. The Map is modified in-place.

Examples

Basic Usage

const fruits = new Map();

fruits.set('apple', 5);
fruits.set('banana', 3);
fruits.set('orange', 8);

console.log(fruits.size); // 3

fruits.clear();

console.log(fruits.size); // 0

Clearing After Processing

const cache = new Map();

// Populate cache with expensive computations
function getCachedData(key) {
  if (cache.has(key)) {
    return cache.get(key);
  }
  const data = computeExpensiveData(key);
  cache.set(key, data);
  return data;
}

// Later, clear the entire cache
cache.clear();

Common Patterns

Cache Reset Pattern

The most common use for clear() is resetting a cache:

class DataManager {
  constructor(maxSize = 100) {
    this.cache = new Map();
    this.maxSize = maxSize;
  }

  get(key) {
    if (this.cache.has(key)) {
      const value = this.cache.get(key);
      // Move to end (most recently used)
      this.cache.delete(key);
      this.cache.set(key, value);
      return value;
    }
    return null;
  }

  set(key, value) {
    // Evict oldest if at capacity
    if (this.cache.size >= this.maxSize) {
      const firstKey = this.cache.keys().next().value;
      this.cache.delete(firstKey);
    }
    this.cache.set(key, value);
  }

  reset() {
    this.cache.clear();
  }
}

const manager = new DataManager(3);
manager.set('a', 1);
manager.set('b', 2);
manager.set('c', 3);

manager.reset(); // Cache is now empty

Session Data Management

class SessionStore {
  constructor() {
    this.userData = new Map();
  }

  setSession(userId, data) {
    this.userData.set(userId, {
      ...data,
      loginTime: Date.now()
    });
  }

  endSession(userId) {
    this.userData.delete(userId);
  }

  logoutAll() {
    // Clear all active sessions
    this.userData.clear();
  }

  isEmpty() {
    return this.userData.size === 0;
  }
}

const sessions = new SessionStore();
sessions.setSession('user1', { name: 'Alice' });
sessions.setSession('user2', { name: 'Bob' });

sessions.logoutAll(); // All users logged out

Clear vs Reassign

There are two ways to empty a Map:

const map = new Map([['a', 1], ['b', 2]]);

// Method 1: clear() - modifies existing Map
map.clear();
// map.size === 0, map still references the same object

// Method 2: Reassign to new Map
const map2 = new Map([['a', 1], ['b', 2]]);
map2 = new Map();
// Creates new Map, old one may be garbage collected

The clear() method is preferred when you want to:

Keep the same Map reference
Avoid creating a new object
Explicitly signal “emptying” in code

Periodic Cleanup

const temporaryData = new Map();

// Add data with timestamps
temporaryData.set('task1', { data: 'result', timestamp: Date.now() });
temporaryData.set('task2', { data: 'result', timestamp: Date.now() });

function cleanupOldEntries(maxAge = 3600000) {
  const now = Date.now();
  for (const [key, value] of temporaryData) {
    if (now - value.timestamp > maxAge) {
      temporaryData.delete(key);
    }
  }
}

// Clear everything after processing
function finishBatch() {
  const count = temporaryData.size;
  temporaryData.clear();
  return `Processed ${count} entries`;
}

Event Listener Management

class EventEmitter {
  constructor() {
    this.listeners = new Map();
  }

  on(event, callback) {
    if (!this.listeners.has(event)) {
      this.listeners.set(event, []);
    }
    this.listeners.get(event).push(callback);
  }

  removeAllListeners(event) {
    if (event) {
      this.listeners.delete(event);
    } else {
      // Remove all listeners for all events
      this.listeners.clear();
    }
  }
}

const emitter = new EventEmitter();
emitter.on('click', () => console.log('clicked'));
emitter.on('hover', () => console.log('hovered'));

// Clear all listeners
emitter.removeAllListeners();