Symbol Type

By specification, object property keys can be both of string kind, or of symbol kind. Not numbers, not booleans, most effective strings or symbols, those two types.

Till now we’ve been using simplest strings. Now permit’s see the advantages that symbols can give us.


A “image” represents a compSYMBOL letely unique identifier.

A price of this kind can be created the use of Symbol():

// identification is a brand new image

allow identification = Symbol();

Upon advent, we will provide symbol an outline (additionally SYMBOL called a symbol call), typically useful for debugging functions:

// id is a image with the description “identity”

let id = Symbol(“identification”);

Symbols are guaranteed to be precise. Even if we create many symbols with the equal description, they are specific values. The description is only a label that doesn’t affect something.

For example, right here aresymbols with the same description – they may be no longer equal:

allow id1 = Symbol(“id”);

let id2 = Symbol(“id”);alert(id1 == id2); // fake

If you’re acquainted with Ruby or any other language that still has a few form of “symbols” – please don’t be erroneous. JavaScript symbols are different.

Symbols don’t auto-convert to a string

Most values in JavaScript assist implicit conversion to a string. For instance, we are able to alert nearly any value, and it’ll work. Symbols are special. They don’t vehicle-convert.

For instance, this alert will show an mistakes:

let identity = Symbol(“identification”);

alert(id); // TypeError: Cannot convert a Symbol price to a string

That’s a “language defend” against messing up, due to the fact strings and symbols are fundamentally exclusive and must no longer accidentally convert one into some other.

If we really want to show a symbol, we want to explicitly call .toString() on it, like here:

let id = Symbol(“identification”);

alert(id.toString()); // Symbol(identity), now it works

Or get image.description property to reveal the outline only:

let id = Symbol(“identity”);

alert(id.description); // id“Hidden” homes

Symbols permit us to create “hidden” homes of an object, that no different a part of code can by accident get right of entry to or overwrite.

For example, if we’re working with person items, that belong to a 3rd-birthday celebration code. We’d like to feature identifiers to them.

Let’s use a symbol key for it:

let consumer =// belongs to every other codename: “John”

;let identity = Symbol(“identity”);consumer[identification] = 1;alert( user[identity] ); // we will get entry to the statistics the usage of the image as the important thing

What’s the advantage of the use of Symbol(“identification”) over a string “id”?

As user objects belongs to every other code, and that code also works with them, we shouldn’t just add any fields to it. That’s unsafe. But a image cannot be accessed by chance, the 1/3-celebration code probably gained’t even see it, so it’s possibly all right to do.

Also, consider that any other script desires to have its personal identifier inside user, for its very own purposes. That can be every other JavaScript library, so that the scripts are absolutely unaware of SYMBOL each different.

Then that script can create its very own Symbol(“identification”), like this:

// …

allow identity = Symbol(“id”);person[identification] = “Their identity value”;

There could be no war between our and their identifiers, because symbols are always one of a kind, despite the fact that they have the identical call.

…But if we used a string “identification” instead of a symbol for the identical purpose, then there could be a warfare:

let person =name: “John” ;// Our script uses “id” assets

user.identification = “Our identity fee”;// …Another script additionally desires “identity” for its purposes…consumer.identity = “Their identity fee”

// Boom! overwritten by way of some other script!Symbols in an item literal

If we need to apply a image in an item literal …, we need rectangular brackets around it.

Like this:

let id = SYMBOL Symbol(“id”);allow person = call: “John”,[id]: 123 // now not “identity”: 123


That’s due to the fact we need the value from the variable id as the important thing, no longer the string “id”.

Symbols are skipped by for…in

Symbolic houses do no longer participate in loop.

For example:

permit identity = Symbol(“identity”);

let person = call: “John”,age: 30,[identity]: 123

;for (allow key in consumer) alert(key); // name, age (no symbols)// the direct get admission to by the symbol works

alert( “Direct: ” + consumer[identification] );

Object.keys(person) also ignores them. That’s a part of the general “hiding symbolic houses” precept. If some other script or a library loops over our item, it received’tget entry to a symbolic belongings.

In contrast, Object.assign copies both string and image houses:

let id = Symbol(“identification”);

allow person = [identification]: 123

;permit clone = Object.assign(, consumer);alert( clone[id] ); // 123

There’s no paradox right here. That’s by layout. The concept is that when we clone an item or merge items, we commonly need all residences to be copied (consisting of symbols like identification).

Global symbols

As we’ve visible, normally all symbols are different, although they have got the same call. But from time to time we want equal-named symbols to be same entities. For example, distinctive parts of our utility want to get entry to symbol “identification” meaning exactly the identical assets.

To gain that, there exists a international image registry. We can create symbols in it and get right of entry to them later, and it guarantees that repeated accesses via the identical name go back exactly the identical symbol.

In order to read (create if absent) a image from the registry, use Symbol.for(key).

That name exams the worldwide registry, and if there’s a image defined as key, then returns it, in any other case creates a brand new symbol Symbol(key) and shops it within the registry by way of the given key.

For example:

// study from the global registry

permit identity = Symbol.for(“identification”); // if the image did now not exist, SYMBOL it’s miles created// examine it again (perhaps from another a part of the code)

let idAgain = Symbol.for(“identity”);// the same image

alert( identity === idAgain ); // proper

Symbols in the registry are called international symbols. If we want an utility-extensive image, on hand anywhere in the code – that’s what they may be for.

That sounds like Ruby

In some programming languages, like Ruby, there’s a unmarried symbol in keeping with call.

In JavaScript, as we are able to see, that’s right for international symbols.


For worldwide symbols, no longer best Symbol.for(key) returns a symbol via name, but there’s a reverse name: Symbol.keyFor(sym), that does the opposite: returns a name by way of a international image.

For example:

// get symbol by call

allow sym = Symbol.for(“call”);

permit sym2 = Symbol.for(“id”);// get call by symbol

alert( Symbol.keyFor(sym) ); // call

alert( Symbol.keyFor(sym2) ); // identification

The Symbol.keyFor internally uses the global symbol registry to look up the important thing for the image. So it doesn’t paintings for non-international symbols. If the image isn’t worldwide, it received’t be capable of locate it and returns undefined.

That said, any symbols have description belongings.

For example:

permit globalSymbol = Symbol.for(“call”);

let localSymbol = Symbol(“call”);alert( Symbol.keyFor(globalSymbol) ); // name, international image

alert( Symbol.keyFor(localSymbol) ); // undefined, now not globalalert( localSymbol.description ); // nameSystem symbols

There exist many “machine” symbols that JavaScript uses internally, and we will use them to high-quality-music numerous aspects of our items.

They are indexed inside the specification within the Well-recognised symbols desk:





…and so on.

For instance, Symbol.toPrimitive allows us to describe item to primitive conversion. We’ll see its use very quickly.

Other symbols can even emerge as familiar whilst we observe the corresponding language functions.


Symbol is a primitive kind for particular identifiers.

Symbols are created with Symbol() call with an non-obligatory description (call).

Symbols are continually extraordinary values, even supposing they have got the same call. If we need equal-named symbols to be equal, then we should use the worldwide registry: Symbol.for(key) returns (creates if needed) a global symbol with key because the name. Multiple calls of Symbol.for with the same key go back precisely the identical image.

Symbols havemain use instances:

“Hidden” item homes.

If we need to feature a property into an object that “belongs” to some other script or a library, we are able to create a image and use it as a assets key. A symbolic property does not seem in, so it received’t be by chance processed together with different properties. Also it received’t be accessed without delay, because any other script does not have our symbol. So the belongings might be protected from accidental use or overwrite.

So we will “covertly” cover something into objects that we want, however others should no longer see, the usage of symbolic houses.

There are many gadget symbols used by JavaScript that are accessible as Symbol.*. We can use them to adjust a few integrated behaviors. For example, later inside the tutorial we’ll use Symbol.iterator for iterables, Symbol.toPrimitive to setup item-to-primitive conversion and so forth.

Technically, symbols aren’t a hundred% hidden. There is a integrated method Object.getOwnPropertySymbols(obj) that permits us to get all symbols. Also there is a technique named Reflect.ownKeys(obj) that returns all keys of an item which include symbolic ones. So they may be now not really hidden. But most libraries, built-in capabilities and syntax constructs don’t use those methods.

Leave a Reply

Your email address will not be published. Required fields are marked *