Unlike strings, where two identical-looking values are considered equal, every Symbol you create is unique, even if you give it the exact same description.

let sym1 = Symbol("id");
let sym2 = Symbol("id");

console.log(sym1 === sym2); // false

That description inside the parentheses, "id", is purely for your own debugging convenience, it doesn't affect uniqueness at all. Even with the identical description, sym1 and sym2 are two completely different values that will never accidentally equal each other.

console.log(typeof sym1); // "symbol"

 

The Problem Symbol Actually Solves

Here's a scenario where this genuinely matters. Say you're adding a property to an object, but you want to be absolutely sure it never accidentally clashes with a property someone else adds later, especially in a large codebase with multiple contributors.

let user = {
  name: "Vi",
  age: 22
};

let uniqueId = Symbol("id");
user[uniqueId] = 12345;

console.log(user); // { name: "Vi", age: 22, [Symbol(id)]: 12345 }

If you'd used a plain string like "id" instead, and someone else on your team also added a property called "id" for a different reason, one would silently overwrite the other. With a Symbol, that's simply not possible, since no other Symbol, even one with the exact same description, will ever match yours.

let anotherId = Symbol("id");
user[anotherId] = "won't clash with the first one";

console.log(user[uniqueId]);   // 12345
console.log(user[anotherId]);  // "won't clash with the first one"

 

Symbols Stay Hidden From Normal Object Loops

One genuinely useful side effect of Symbols is that they don't show up during normal ways of looping through an object.

let product = {
  name: "Laptop",
  [Symbol("internalId")]: "abc123"
};

console.log(Object.keys(product));        // ["name"]
console.log(JSON.stringify(product));     // {"name":"Laptop"}

The Symbol property is quietly skipped in both cases. This makes Symbols genuinely useful for attaching metadata or internal-only information to an object, data you don't want showing up if someone loops through the object's regular properties or converts it to JSON.

If you specifically need to retrieve Symbol properties, there's a dedicated method for that.

console.log(Object.getOwnPropertySymbols(product)); // [Symbol(internalId)]

 

Where You've Probably Already Seen One

Even if you've never written Symbol() yourself, you've likely used one indirectly. Symbol.iterator is a well-known built-in Symbol that powers how JavaScript loops through things like arrays with for...of.

let numbers = [1, 2, 3];

for (let num of numbers) {
  console.log(num);
}

Under the hood, that loop works because arrays have a Symbol.iterator property defining exactly how to step through their values. You don't need to touch it directly, but it's a good example of Symbols quietly doing real work behind the scenes in the language itself.
 

Conclusion

Frequently Asked Questions (FAQs)

A random string could technically still collide with another one, however unlikely. A Symbol is guaranteed unique by the language itself, no randomness or luck involved.

2.Can I recreate the same Symbol later using its description?

Not with the regular Symbol() function, no, each call always creates a new, unique value. If you genuinely need a shared Symbol accessible by the same key elsewhere, look into Symbol.for(), which maintains a global registry specifically for that purpose.

3.Will I need to use Symbol often as a beginner?

Probably not very often. It's a more specialized tool you'll likely reach for once you're working on larger codebases or libraries where avoiding property name collisions actually becomes a real concern.