Skip to main content

How to Check if a Key or Value Exists in a JavaScript Map

The JavaScript Map object is a powerful data structure for storing key-value pairs. Unlike plain objects, it offers built-in methods to safely and efficiently check for the existence of both keys and values.

This guide will teach you the standard methods for these tasks. You will learn how to use the fast .has() method to check for a key, the common pattern of using .values() to check for a value, and the critical concept of "reference vs. value" when using objects as keys.

The Core Task: Checking if a Key Exists (.has())​

The Map object has a built-in method specifically for this purpose: Map.prototype.has(). It is the simplest, fastest, and most direct way to determine if a key is in a Map.

Syntax​

myMap.has(key)

where:

  • key: The key you want to check for.
  • Returns: true if a key exists in the Map, otherwise false.

Solution​

const myMap = new Map();
myMap.set('name', 'Alice');
myMap.set('id', 123);
myMap.set('isAdmin', false);

// ✅ Correct usage
console.log(myMap.has('name'));    // Output: true
console.log(myMap.has('isAdmin')); // Output: true
console.log(myMap.has('age'));     // Output: false

if (myMap.has('id')) {
  console.log('The "id" key exists.');
}
note

Important: The .has() method checks for the existence of a key, not whether its value is "truthy." It will correctly return true even if a key's value is null or undefined.

const mapWithFalsy = new Map();
mapWithFalsy.set('empty', null);

console.log(mapWithFalsy.has('empty')); // Output: true

The Second Task: Checking if a Value Exists​

Map does not have a built-in .hasValue() method. To check if a value exists, you must first get a list of all values and then search that list.

The logic:

  1. Get an iterator of all values in the Map using the Map.prototype.values() method.
  2. Convert the iterator to an array.
  3. Use the Array.prototype.includes() method to check if the value is in the array.

And the solution:

const myMap = new Map();
myMap.set('user1', 'Alice');
myMap.set('user2', 'Bob');

// 1. Get the values and 2. convert to an array
const valuesArray = [...myMap.values()];
// `valuesArray` is now ['Alice', 'Bob']

// 3. Use .includes() to check for the value
console.log(valuesArray.includes('Alice')); // Output: true
console.log(valuesArray.includes('Charlie')); // Output: false
note

This is the standard and most readable pattern for this task.

Advanced Use Case: Using Objects as Keys​

One of the most powerful features of Map is that it can use objects as keys. However, this comes with a critical caveat: Map uses reference equality (like the === operator) to compare keys.

This means two different objects with the exact same content are considered different keys.

Example of code with problems:

const map = new Map();
const user1 = { id: 1 };
const user2 = { id: 1 }; // Looks the same, but is a different object in memory

map.set(user1, 'Alice');

console.log(user1 === user2); // Output: false

// This will NOT find the key, because `user2` is a different object.
console.log(map.has(user2));  // Output: false

// This WILL find the key, because it's the exact same object reference.
console.log(map.has(user1));  // Output: true

The solution is "Iteration" (if you don't have the reference to the original object). If you don't have the original object reference and need to find a key by its content, you must loop through the map's keys.

const map = new Map();
const userKey = { id: 1 };
map.set(userKey, 'Alice');

let keyWasFound = false;
for (const key of map.keys()) {
  // Check the content of the key object
  if (key.id === 1) {
    keyWasFound = true;
    break; // Stop the loop once found
  }
}

console.log(keyWasFound); // Output: true

Conclusion​

The JavaScript Map provides clear and efficient methods for checking for the existence of keys and values.

The key takeaways are:

  1. To check if a key exists, use the built-in .has(key) method. It is fast, direct, and the recommended best practice.
  2. To check if a value exists, you must first get all values with .values(), convert them to an array ([...myMap.values()]), and then use .includes(value).
  3. When using objects as keys, Map checks for object identity (reference), not value. If you don't have the original object reference, you must loop through the keys to find a match by content.

Table of Contents