To create a new primitive Symbol, you writeSymbol() with an optional string as its description:

const sym1 = Symbol();const sym2 = Symbol("foo");const sym3 = Symbol("foo");

The above code creates three new Symbols. Note thatSymbol("foo") does not coerce the string"foo" into a Symbol. It creates a new Symbol each time:

Symbol("foo") === Symbol("foo"); // false

The following syntax with thenew operator will throw aTypeError:

const sym = new Symbol(); // TypeError

This prevents authors from creating an explicitSymbol wrapper object instead of a new Symbol value and might be surprising as creating explicit wrapper objects around primitive data types is generally possible (for example,new Boolean,new String andnew Number).

If you really want to create aSymbol wrapper object, you can use theObject() function:

const sym = Symbol("foo");typeof sym; // "symbol"const symObj = Object(sym);typeof symObj; // "object"

Because symbols are the only primitive data type that has reference identity (that is, you cannot create the same symbol twice), they behave like objects in some way. For example, they are garbage collectable and can therefore be stored inWeakMap,WeakSet,WeakRef, andFinalizationRegistry objects.

The above syntax using theSymbol() function will create a Symbol whose value remains unique throughout the lifetime of the program. To create Symbols available across files and even across realms (each of which has its own global scope), use the methodsSymbol.for() andSymbol.keyFor() to set and retrieve Symbols from the global Symbol registry.

Note that the "global Symbol registry" is only a fictitious concept and may not correspond to any internal data structure in the JavaScript engine — and even if such a registry exists, its content is not available to the JavaScript code, except through thefor() andkeyFor() methods.

The methodSymbol.for(tokenString) takes a string key and returns a symbol value from the registry, whileSymbol.keyFor(symbolValue) takes a symbol value and returns the string key corresponding to it. Each is the other's inverse, so the following istrue:

Symbol.keyFor(Symbol.for("tokenString")) === "tokenString"; // true

Because registered symbols can be arbitrarily created anywhere, they behave almost exactly like the strings they wrap. Therefore, they are not guaranteed to be unique and are not garbage collectable. Therefore, registered symbols are disallowed inWeakMap,WeakSet,WeakRef, andFinalizationRegistry objects.

All static properties of theSymbol constructor are Symbols themselves, whose values are constant across realms. They are known aswell-known Symbols, and their purpose is to serve as "protocols" for certain built-in JavaScript operations, allowing users to customize the language's behavior. For example, if a constructor function has a method withSymbol.hasInstance as its name, this method will encode its behavior with theinstanceof operator.

Prior to well-known Symbols, JavaScript used normal properties to implement certain built-in operations. For example, theJSON.stringify function will attempt to call each object'stoJSON() method, and theString function will call the object'stoString() andvalueOf() methods. However, as more operations are added to the language, designating each operation a "magic property" can break backward compatibility and make the language's behavior harder to reason with. Well-known Symbols allow the customizations to be "invisible" from normal code, which typically only read string properties.

Well-known symbols do not have the concept of garbage collectability, because they come in a fixed set and are unique throughout the lifetime of the program, similar to intrinsic objects such asArray.prototype, so they are also allowed inWeakMap,WeakSet,WeakRef, andFinalizationRegistry objects.

The methodObject.getOwnPropertySymbols() returns an array of Symbols and lets you find Symbol properties on a given object. Note that every object is initialized with no own Symbol properties, so that this array will be empty unless you've set Symbol properties on the object.

Symbol()

Returns primitive values of type Symbol. Throws an error when called withnew.

The static properties are all well-known Symbols. In these Symbols' descriptions, we will use language like "Symbol.hasInstance is a method determining…", but bear in mind that this is referring to the semantic of an object's method having this Symbol as the method name (because well-known Symbols act as "protocols"), not describing the value of the Symbol itself.

Symbol.asyncIterator

A method that returns the default AsyncIterator for an object. Used byfor await...of.

Symbol.hasInstance

A method determining if a constructor object recognizes an object as its instance. Used byinstanceof.

Symbol.isConcatSpreadable

A Boolean value indicating if an object should be flattened to its array elements. Used byArray.prototype.concat().

Symbol.iterator

A method returning the default iterator for an object. Used byfor...of.

Symbol.match

A method that matches against a string, also used to determine if an object may be used as a regular expression. Used byString.prototype.match().

Symbol.matchAll

A method that returns an iterator, that yields matches of the regular expression against a string. Used byString.prototype.matchAll().

Symbol.replace

A method that replaces matched substrings of a string. Used byString.prototype.replace().

Symbol.search

A method that returns the index within a string that matches the regular expression. Used byString.prototype.search().

Symbol.species

A constructor function that is used to create derived objects.

Symbol.split

A method that splits a string at the indices that match a regular expression. Used byString.prototype.split().

Symbol.toPrimitive

A method converting an object to a primitive value.

Symbol.toStringTag

A string value used for the default description of an object. Used byObject.prototype.toString().

Symbol.unscopables

An object value of whose own and inherited property names are excluded from thewith environment bindings of the associated object.

Symbol.for()

Searches for existing registered Symbols in the global Symbol registry with the givenkey and returns it if found. Otherwise a new Symbol gets created and registered withkey.

Symbol.keyFor()

Retrieves a shared Symbol key from the global Symbol registry for the given Symbol.

These properties are defined onSymbol.prototype and shared by allSymbol instances.

Symbol.prototype.constructor

The constructor function that created the instance object. ForSymbol instances, the initial value is theSymbol constructor.

Symbol.prototype.description

A read-only string containing the description of the Symbol.

Symbol.prototype[Symbol.toStringTag]

The initial value of the[Symbol.toStringTag] property is the string"Symbol". This property is used inObject.prototype.toString(). However, becauseSymbol also has its owntoString() method, this property is not used unless you callObject.prototype.toString.call() with a symbol asthisArg.

Symbol.prototype.toString()

Returns a string containing the description of the Symbol. Overrides theObject.prototype.toString() method.

Symbol.prototype.valueOf()

Returns the Symbol. Overrides theObject.prototype.valueOf() method.

Symbol.prototype[Symbol.toPrimitive]()

Returns the Symbol.

Thetypeof operator can help you to identify Symbols.

typeof Symbol() === "symbol";typeof Symbol("foo") === "symbol";typeof Symbol.iterator === "symbol";

Some things to note when working with type conversion of Symbols.

• When trying to convert a Symbol to a number, aTypeError will be thrown(e.g.,+sym orsym | 0).
• When using loose equality,Object(sym) == sym returnstrue.
• Symbol("foo") + "bar" throws aTypeError (can't convert Symbol to string). This prevents you from silently creating a new string property name from a Symbol, for example.
• The"safer"String(sym) conversion works like a call toSymbol.prototype.toString() with Symbols, but note thatnew String(sym) will throw.

Symbols are not enumerable infor...in iterations. In addition,Object.getOwnPropertyNames() will not return Symbol object properties, however, you can useObject.getOwnPropertySymbols() to get these.

const obj = {};obj[Symbol("a")] = "a";obj[Symbol.for("b")] = "b";obj["c"] = "c";obj.d = "d";for (const i in obj) {  console.log(i);}// "c" "d"

Symbol-keyed properties will be completely ignored when usingJSON.stringify():

JSON.stringify({ [Symbol("foo")]: "foo" });// '{}'

For more details, seeJSON.stringify().

When a Symbol wrapper object is used as a property key, this object will be coerced to its wrapped Symbol:

const sym = Symbol("foo");const obj = { [sym]: 1 };obj[sym]; // 1obj[Object(sym)]; // still 1

• Polyfill ofSymbol incore-js
• typeof
• JavaScript data types and data structures
• ES6 In Depth: Symbols on hacks.mozilla.org (2015)