What is a Symbol used for in JavaScript?

A Symbol is a primitive value that is always unique, even when two symbols share the same description. It's mainly used as an object property key that won't collide with string keys or other symbols. JavaScript also uses symbols internally for well-known protocol hooks like Symbol.iterator.

Why doesn't JSON.stringify include my symbol properties?

JSON.stringify only serializes string-keyed, enumerable own properties by design. Symbol-keyed properties are intentionally excluded, along with functions and undefined values. This makes symbols a good fit for metadata you don't want accidentally serialized or logged.

What is the difference between Symbol() and Symbol.for()?

Symbol() always creates a brand-new, unique symbol, even if you pass the same description twice. Symbol.for() checks a global registry first and returns an existing symbol if one was already registered under that key. Use Symbol.for() when separate parts of an app, or separate realms like iframes, need to share the same symbol.

What are well-known symbols and why do they matter?

Well-known symbols are built-in symbols like Symbol.iterator that let your objects plug into core language behavior. Implementing Symbol.iterator makes an object work with for...of and spread syntax. Implementing Symbol.toPrimitive controls how an object converts to a number or string.

Can I still access a symbol property if it's hidden from for...in?

Yes, hidden from enumeration doesn't mean private. Use Object.getOwnPropertySymbols() to list all symbol keys on an object directly. Anyone with a reference to the same symbol can also read or write that property normally.

JavaScript Symbols

What Symbols Are

Symbol() creates a new primitive value that is guaranteed unique, even with an identical description.
```
const a = Symbol('id');
const b = Symbol('id');
a === b; // false
```
Symbols are a primitive type alongside string, number, boolean, undefined, null, and bigint.

The optional description passed to Symbol() is only for debugging and doesn't affect identity.

const s = Symbol('debug label');
s.toString(); // "Symbol(debug label)"
s.description; // "debug label"

Calling Symbol() with new throws a TypeError, since symbols aren't constructible.
Each symbol exists as its own independent value, with no relationship to symbols of the same description.
Typeof a symbol returns the string "symbol".

Symbols as Object Keys

Use a symbol as a property key to guarantee it never collides with any other key.

const ID = Symbol('id');
const user = { name: 'Ada', [ID]: 42 };
user[ID]; // 42

Access a symbol-keyed property with bracket notation, since dot notation can't reference a variable.
Symbol keys are useful for adding metadata to objects without risking a clash with existing or future string keys.
```
const TAG = Symbol('internal-tag');
function tag(obj, value) {
  obj[TAG] = value;
  return obj;
}
```
Symbol-keyed properties still show up in Object.getOwnPropertyDescriptors() and Reflect.ownKeys().
```
Reflect.ownKeys(user); // ['name', Symbol(id)]
```
Symbols don't make a property truly private — anyone holding the symbol reference can read it.
Mixing symbol and string keys on the same object is common for separating public data from internal flags.

Symbols Are Skipped By Enumeration

for...in and Object.keys() ignore symbol-keyed properties entirely.

const obj = { name: 'Ada', [Symbol('id')]: 1 };
Object.keys(obj); // ['name']
for (const key in obj) console.log(key); // logs 'name' only

JSON.stringify() also drops symbol-keyed properties from the resulting JSON string.
```
JSON.stringify(obj); // '{"name":"Ada"}'
```
This makes symbols a safe place for metadata that shouldn't leak into serialized output or logs.
Use Object.getOwnPropertySymbols() when you explicitly need to list an object's symbol keys.
```
Object.getOwnPropertySymbols(obj); // [Symbol(id)]
```
Object spread ({...obj}) does copy symbol-keyed own properties, unlike JSON.stringify.
Object.assign() also copies enumerable symbol properties between objects.

Well-Known Symbols

Well-known symbols are built-in symbols that let objects hook into core language behavior.

const range = {
  from: 1,
  to: 3,
  [Symbol.iterator]() {
    let cur = this.from;
    const last = this.to;
    return { next: () => cur <= last ? { value: cur++, done: false } : { done: true } };
  }
};
[...range]; // [1, 2, 3]

Symbol.iterator makes an object work with for...of, spread syntax, and destructuring.

Symbol.asyncIterator does the same for for await...of loops over asynchronous data sources.

const asyncRange = {
  async *[Symbol.asyncIterator]() {
    yield 1;
    yield 2;
  }
};

Symbol.toPrimitive controls how an object converts to a number, string, or default value.

const money = {
  amount: 50,
  [Symbol.toPrimitive](hint) {
    return hint === 'string' ? `$${this.amount}` : this.amount;
  }
};
`${money}`; // "$50"
money + 10; // 60

Symbol.hasInstance customizes how instanceof checks behave for a class or object.

class Even {
  static [Symbol.hasInstance](num) {
    return Number.isInteger(num) && num % 2 === 0;
  }
}
4 instanceof Even; // true

The Global Symbol Registry

Symbol.for(key) looks up a symbol in a global registry, creating one if it doesn't exist yet.
```
const a = Symbol.for('app.id');
const b = Symbol.for('app.id');
a === b; // true
```
Unlike Symbol(), calling Symbol.for() with the same key always returns the same shared symbol.
The registry is shared across realms, like the main page and an iframe, in browser environments.
Symbol.keyFor(sym) returns the registry key for a given registered symbol, or undefined if unregistered.
```
Symbol.keyFor(a); // "app.id"
Symbol.keyFor(Symbol('local')); // undefined
```
Use the global registry when independent modules need to coordinate on the exact same symbol value.
Prefer plain Symbol() for most cases — reach for the registry only when cross-module sharing is required.