Het gegevenstype symbool is een primitief gegevenstype. De Symbol() functie geeft een waarde terug (returns a value) van het type symbool, heeft statische eigenschappen die verscheidene leden van ingebouwde objecten blootstelt, heeft statische methoden die het globale symbolregister blootstellen en vertegenwoordigd een ingebouwde objectklasse. Maar is onvolledig als een constructor, omdat het niet de "new Symbol()" syntaxis ondersteund.
Elke waarde teruggekregen van Symbol() is uniek. Zo'n teruggekregen waarde kan, bijvoorbeeld, gebruikt worden als identificatiemiddel voor objecteigenschappen; het primaire doel van dit gegevenstype. Hoewel er andere use-cases zijn, zoals het beschikbaar maken van ondoorzichtige gegevenstypen of als algemeen uniek identificatiemiddel. Meer uitleg over het doel en gebruik van het symbool is te vinden in de woordenlijst.
Om een nieuw primitief symbool te creëren, schrijf je Symbol() met een optionele String als beschrijving:
let sym1 = Symbol()
let sym2 = Symbol('foo')
let sym3 = Symbol('foo')
De bovenstaande code creëert drie nieuwe symbolen. Let er op dat Symbol("foo") niet de string "foo" omzet naar een symbool maar dat het telkens een nieuw uniek symbool creëert:
Symbol('foo') === Symbol('foo') // false
De volgende syntaxis met de {{jsxref("Operators/new", "new")}} operator zal een {{jsxref("TypeError")}}: afwerpen:
let sym = new Symbol() // TypeError
Dit behoed auteurs ervoor om nadrukkelijk een Symbol wrapper-object te creëren in plaats van een nieuwe symboolwaarde. Terwijl normaal gesproken primitieve gegevenstypen wel gemaakt kunnen worden met een wrapper-object. (Zoals: new Boolean, new String en new Number).
Als je echt een Symbol wrapper-object wilt maken, kun je dit doen met de Object() functie:
let sym = Symbol('foo')
typeof sym // "symbol"
let symObj = Object(sym)
typeof symObj // "object"
De bovenstaande syntaxis, die gebruik maakt van de Symbol() functie, creëert alleen niet een globaal symbool dat te gebruiken is door je gehele codebase. Om symbolen te creëren die door al je bestanden en zelfs door je realms (met elk hun eigen globale scope) te gebruiken zijn; gebruik je de methoden {{jsxref("Symbol.for()")}} en {{jsxref("Symbol.keyFor()")}}. Om, respectievelijk, symbolen in het globale symbolenregister aan te maken en terug te krijgen.
De methode {{jsxref("Object.getOwnPropertySymbols()")}} geeft een array met symbolen terug en laat je symbooleigenschappen vinden in een opgegeven object. Let er op dat elk object geïnitialiseerd wordt zonder eigen symbooleigenschappen, dus deze array zal leeg zijn tenzij je een symbool als eigenschap hebt gegeven aan een object.
Symbol()Symbol() constructor geeft een waarde terug van het type symbol, maar is incompleet als een constructor omdat het niet de "new Symbol()" syntaxis ondersteund.for await...of.for...of.with environment bindings of the associated object.key and returns it if found. Otherwise a new symbol gets created in the global symbol registry with key.The {{jsxref("Operators/typeof", "typeof")}} 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.
+sym or sym | 0).Object(sym) == sym returns true.Symbol("foo") + "bar" throws a {{jsxref("TypeError")}} (can't convert symbol to string). This prevents you from silently creating a new string property name from a symbol, for example.String(sym) conversion works like a call to {{jsxref("Symbol.prototype.toString()")}} with symbols, but note that new String(sym) will throw.Symbols are not enumerable in for...in iterations. In addition, {{jsxref("Object.getOwnPropertyNames()")}} will not return symbol object properties, however, you can use {{jsxref("Object.getOwnPropertySymbols()")}} to get these.
let obj = {}
obj[Symbol('a')] = 'a'
obj[Symbol.for('b')] = 'b'
obj['c'] = 'c'
obj.d = 'd'
for (let i in obj) {
console.log(i) // logs "c" and "d"
}
Symbol-keyed properties will be completely ignored when using JSON.stringify():
JSON.stringify({[Symbol('foo')]: 'foo'})
// '{}'
For more details, see {{jsxref("JSON.stringify()")}}.
When a Symbol wrapper object is used as a property key, this object will be coerced to its wrapped symbol:
let sym = Symbol('foo')
let obj = {[sym]: 1}
obj[sym] // 1
obj[Object(sym)] // still 1
| Specification |
|---|
| {{SpecName('ESDraft', '#sec-symbol-objects', 'Symbol')}} |
{{Compat("javascript.builtins.Symbol")}}