Does JavaScript Have Dictionaries? A Practical Guide

Does JavaScript Have Dictionaries?

Dictionaries are collections of key-value pairs used for fast lookups. In JavaScript there is no separate dictionary type; instead you rely on objects or the Map class. Conceptually, a dictionary maps a key to a value and allows quick retrieval by that key. This is why developers often refer to an object or a Map as a dictionary in everyday code. The practical takeaway is that dictionary-like structures are a core pattern in JavaScript, enabling you to model real world mappings such as user records, configuration settings, or caches.

How JavaScript Implements Dictionaries

JavaScript provides two primary dictionary implementations: plain objects and Map. An object is created with an object literal like {} and uses string keys by default, accessible via dot notation or bracket notation, e.g., obj.name or obj["name"]. A Map is created with new Map() and accepts any value as a key, with methods set, get, has, and delete. Maps also preserve insertion order, which can matter for iteration. For most simple dictionaries, an object is sufficient; for more advanced uses that require non-string keys or guaranteed order, Map is often a better fit. Keep in mind that objects carry a prototype, which can affect keys, while Maps do not have that issue.

Prototypical Pitfalls with Objects as Dictionaries

A plain object is a lightweight dictionary, but it inherits properties from the Object.prototype. This can lead to accidental keys or key collisions, or you might retrieve keys like toString that you did not intend to store. A common fix is to use Object.create(null) to create a dictionary with no prototype, and to check for keys with Object.prototype.hasOwnProperty.call(dict, key) rather than direct access. When iterating, prefer Object.keys(dict) or Object.entries(dict) to avoid surprises. If you plan to serialize to JSON, remember that nonstring keys will be converted to strings, which may not be what you expect.

The Map Alternative for Dictionary Like Data

If you need keys that are not strings or symbols, or you require reliable insertion order guarantees, Map is the better tool. Map keeps track of the number of entries via the size property and provides iterable interfaces for keys, values, and entries. You can chain operations, and Map can be cleared or reset efficiently.

Practical Dictionary Patterns in JavaScript

Here are patterns you can apply today:

• Simple dictionary with string keys using an object: const dict = { a: 1, b: 2 }; dict.c = 3; console.log(dict["a"]);
• Mutable dictionary using Object.create(null): const dict = Object.create(null); dict.x = 10;
• Dictionary with Map when non-string keys are needed: const map = new Map(); map.set({id:1}, 'obj');
• Iterating keys: Object.keys(dict) or map.forEach((v,k)=>...).
• Existence checks: k in dict or map.has(k).

Dictionaries and JSON: What You Need to Know

JSON is built around plain objects and arrays. When you stringify dictionaries backed by objects, keys become JSON object properties. If you use Map, default JSON.stringify does not include its entries; you will need to convert Map to an array of entries or an object before serialization. When you parse JSON back, you typically reconstruct the dictionary by iterating keys. Remember that all JSON object keys are strings.

Authority sources and best practices

Having a dictionary that is easy to maintain means choosing the right container for the job. For simple key-value lookups with string keys, a plain object is usually the best fit. If you require non-string keys, insertion order guarantees, or richer API surface, prefer Map. Always consider JSON interoperability when designing API payloads.