---
title: Symbol
slug: Web/JavaScript/Reference/Global_Objects/Symbol
tags:
  - ECMAScript 2015
  - ECMAScript6
  - JavaScript
  - Symbol
translation_of: Web/JavaScript/Reference/Global_Objects/Symbol
---
<div>{{JSRef}}</div>

<p>La funzione <code>Symbol()</code> restituisce un valore di tipo <strong>symbol</strong>, dispone di proprietà statiche che espongono diversi membri di oggetti built-in, ha metodi statici che espongono il registro globale dei symbol, ed assomiglia all'oggetto built-in class, ma non dispone di un costruttore e non supporta la sintassi "<code>new Symbol()</code>".  </p>

<p>Ogni valore symbol restituito da <code>Symbol()</code> è unico.  Un valore symbol può essere utilizzato come identificatore per proprietà di un oggetto; questo è lo scopo di tale tipo di dati.  Ulteriori spiegazioni circa il loro scopo ed uso può essere trovato nella pagina: <a href="/en-US/docs/Glossary/Symbol">glossary entry for Symbol</a>.</p>

<p>Il tipo di dati <strong>symbol</strong> è un {{Glossary("Primitive", "primitive data type")}}.</p>

<h2 id="Syntax">Syntax</h2>

<pre class="syntaxbox">Symbol(<em>[description]</em>)</pre>

<h3 id="Parametri">Parametri</h3>

<dl>
 <dt><code>description</code> {{optional_inline}}</dt>
 <dd>Opzionale, string. Una descrizione del symbol che può essere usata per il debug ma non per accedere al symbol stesso.</dd>
</dl>

<h2 id="Descrizione">Descrizione</h2>

<p>Per creare un nuovo primitive symbol, scrivere<code>Symbol()</code> con una stringa opzionale di descrizione:</p>

<pre class="brush: js">var sym1 = Symbol();
var sym2 = Symbol('foo');
var sym3 = Symbol('foo');
</pre>

<p>Il codice sopra crea tre nuovi symbol. Notare che <code>Symbol("foo")</code> non costringe la stringa "foo" in un symbol. Esso crea un nuovo symbol ogni volta:</p>

<pre class="brush: js">Symbol('foo') === Symbol('foo'); // false</pre>

<p>La sintassi seguente con l'operatore {{jsxref("Operators/new", "new")}} genererà un {{jsxref("TypeError")}}:</p>

<pre class="brush: js">var sym = new Symbol(); // TypeError</pre>

<p>Questo previene gli autori dal creare un esplicito oggetto wrapper <code>Symbol</code> invece di un nuovo valore symbol e la cosa può sorprendere in quanto creare un oggetto wrapper esplicito attorno ad un tipo di dati primitivo è generalmente possibile (ad esempio, <code>new Boolean</code>, <code>new String</code> e <code>new Number</code>).</p>

<p>Se veramente si vuole creare un oggetto wrapper <code>Symbol</code> si può usare la funzione <code>Object()</code>:</p>

<pre class="brush: js">var sym = Symbol('foo');
typeof sym;     // "symbol"
var symObj = Object(sym);
typeof symObj;  // "object"
</pre>

<h3 id="Symbols_condivisi_nel_registro_globale_dei_symbol">Symbols condivisi nel registro globale dei symbol</h3>

<p>La sintassi vista sopra che utilizza la funzione <code>Symbol()</code> non crea un symbol globale che sarà disponibile nell'intero codebase. Per creare dei symbol disponibili attraverso diversi files ed anche attraverso diversi realms (ognuno dei quali ha il proprio global scope), usare i metodi {{jsxref("Symbol.for()")}} e {{jsxref("Symbol.keyFor()")}} per impostare e leggere i symbol dal registro globale.</p>

<h3 id="Cercare_le_proprietà_symbol_negli_oggetti">Cercare le proprietà symbol negli oggetti</h3>

<p>Il metodo {{jsxref("Object.getOwnPropertySymbols()")}} restituisce un array di symbol e permette di trovare le proprietà symbol di un oggetto. Notare che ogni oggetto è inizializzato senza alcuna proprietà symbol, per cui l'array restituito sarà vuoto a meno che una proprietà symbol non sia stata creata sull'oggetto.</p>

<h2 id="Proprietà">Proprietà</h2>

<dl>
 <dt><code>Symbol.length</code></dt>
 <dd>Proprietà "lunghezza", il cui valore è 0.</dd>
 <dt>{{jsxref("Symbol.prototype")}}</dt>
 <dd>Rappresenta il prototype del costruttore <code>Symbol</code>.</dd>
</dl>

<h3 id="Symbols_ben_noti">Symbols ben noti</h3>

<p>In aggiunta ai symbol definiti da voi, JavaScript dispone di alcuni symbol built-in che rappresentano alcuni comportamenti interni del linguaggio che non sono esposti agli sviluppatori in ECMAScript5 e precedenti. A tali symbol si può accedere tramite le seguenti proprietà:</p>

<h4 id="Symbols_di_iterazione">Symbols di iterazione</h4>

<dl>
 <dt>{{jsxref("Symbol.iterator")}}</dt>
 <dd>Un metodo che restituisce l'iteratore di default per un oggetto. Usato da <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...of"><code>for...of</code></a>.</dd>
 <dt>{{jsxref("Symbol.asyncIterator")}} {{experimental_inline}}</dt>
 <dd>Un metodo che restituisce l'iteratore asincrono di default per un oggetto. Usato da <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for-await-of"><code>for await of</code></a>.</dd>
</dl>

<h4 id="Symbols_per_le_espressioni_regolari">Symbols per le espressioni regolari</h4>

<dl>
 <dt>{{jsxref("Symbol.match")}}</dt>
 <dd>Un metodo che effettua la corrispondenza su una stringa, usato anche per determinare se un oggetto può essere utilizzato come espressione regolare. Usato da {{jsxref("String.prototype.match()")}}.</dd>
 <dt>{{jsxref("Symbol.replace")}}</dt>
 <dd>Un metodo che sostituisce le sottostringhe di una stringa corrispondenti. Usato da {{jsxref("String.prototype.replace()")}}.</dd>
 <dt>{{jsxref("Symbol.search")}}</dt>
 <dd>Un metodo che restituisce l'indice all'interno di una stringa che corrisponde all'espressione regolare. Usato da {{jsxref("String.prototype.search()")}}.</dd>
 <dt>{{jsxref("Symbol.split")}}</dt>
 <dd>Un metodo che divide una stringa all'indice corrispondente ad una espressione regolare. Usato da {{jsxref("String.prototype.split()")}}.</dd>
</dl>

<h4 id="Altri_symbols">Altri symbols</h4>

<dl>
 <dt>{{jsxref("Symbol.hasInstance")}}</dt>
 <dd>Un metodo che determina se un oggetto costruttore riconosce un oggetto come propria istanza. Usato da {{jsxref("Operators/instanceof", "instanceof")}}.</dd>
 <dt>{{jsxref("Symbol.isConcatSpreadable")}}</dt>
 <dd>Un valore booleano indicante se un oggetto deve essere appiattito ai soui elementi array. Usato da {{jsxref("Array.prototype.concat()")}}.</dd>
 <dt>{{jsxref("Symbol.unscopables")}}</dt>
 <dd>An object value of whose own and inherited property names are excluded from the <code><a href="/en-US/docs/Web/JavaScript/Reference/Statements/with">with</a></code> environment bindings of the associated object.</dd>
 <dt>{{jsxref("Symbol.species")}}</dt>
 <dd>Una funzione costruttore utilizzata per creare oggetti derivati.</dd>
 <dt>{{jsxref("Symbol.toPrimitive")}}</dt>
 <dd>Un metodo che converte un oggetto in un valore primitivo.</dd>
 <dt>{{jsxref("Symbol.toStringTag")}}</dt>
 <dd>Una stringa usata per la descizione di default di un oggetto. Usato da {{jsxref("Object.prototype.toString()")}}.</dd>
</dl>

<h2 id="Metodi">Metodi</h2>

<dl>
 <dt>{{jsxref("Symbol.for()", "Symbol.for(key)")}}</dt>
 <dd>Cerca la "key" fornita tra i symbol esistenti e la restituisce nel caso in cui venga trovata. In caso contrario un nuovo symbol viene creato nel registro globale dei symbol con la "key" indicata.</dd>
 <dt>{{jsxref("Symbol.keyFor", "Symbol.keyFor(sym)")}}</dt>
 <dd>Trova una chiave symbol condivisa dal registro globale dei symbol per il symbol fornito.</dd>
</dl>

<h2 id="Symbol_prototype"><code>Symbol</code> prototype</h2>

<p>Tutti i simboli ereditano da {{jsxref("Symbol.prototype")}}.</p>

<h3 id="Proprietà_2">Proprietà</h3>

<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Properties')}}</p>

<h3 id="Metodi_2">Metodi</h3>

<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Symbol/prototype','Methods')}}</p>

<h2 id="Esempi">Esempi</h2>

<h3 id="Using_the_typeof_operator_with_symbols">Using the <code>typeof</code> operator with symbols</h3>

<p>L'operatore {{jsxref("Operators/typeof", "typeof")}} può aiutare ad identificare i symbol.</p>

<pre class="brush: js">typeof Symbol() === 'symbol'
typeof Symbol('foo') === 'symbol'
typeof Symbol.iterator === 'symbol'
</pre>

<h3 id="Conversioni_di_tipo_dei_symbol">Conversioni di tipo dei symbol</h3>

<p>Alcune cose da notare quando si lavora con le conversioni di tipo dei symbol.</p>

<ul>
 <li>Quando si prova a convertire un symbol in un numero, un {{jsxref("TypeError")}} verrà generato<br>
  (e.g. <code>+sym</code> or <code>sym | 0</code>).</li>
 <li>Quando si usa l'uguaglianza non stretta, <code>Object(sym) == sym</code> restituisce <code>true.</code></li>
 <li><code>Symbol("foo") + "bar"</code> lancia un {{jsxref("TypeError")}} (non si può convertire un symbol in stringa). Questo previene, ad esempio, la creazione silenziosa di un nuovo nome di proprietà stringa da un symbol.</li>
 <li>La <a href="/en-US/docs/Web/JavaScript/Reference/Global_Objects/String#String_conversion">"safer" <code>String(sym)</code> conversion</a> funziona come una chiamata a {{jsxref("Symbol.prototype.toString()")}} con symbol, ma notare che <code>new String(sym)</code> genererà un errore.</li>
</ul>

<h3 id="Symbols_ed_iterazione_for...in">Symbols ed iterazione <code>for...in</code></h3>

<p>I symbol non sono enumerabili in un'iterazione <a href="/en-US/docs/Web/JavaScript/Reference/Statements/for...in"><code>for...in</code></a>. In aggiunta, {{jsxref("Object.getOwnPropertyNames()")}} non restituirà le proprietà symbol dell'oggetto, tuttavia, si puù usare {{jsxref("Object.getOwnPropertySymbols()")}} per ottenerle.</p>

<pre class="brush: js">var obj = {};

obj[Symbol('a')] = 'a';
obj[Symbol.for('b')] = 'b';
obj['c'] = 'c';
obj.d = 'd';

for (var i in obj) {
   console.log(i); // logs "c" and "d"
}</pre>

<h3 id="Symbols_e_JSON.stringify()">Symbols e <code>JSON.stringify()</code></h3>

<p>Le proprietà le cui chiavi sono symbol vengono completamente ignorate da <code>JSON.stringify()</code>:</p>

<pre class="brush: js">JSON.stringify({[Symbol('foo')]: 'foo'});
// '{}'</pre>

<p>Per ulteriori dettagli, vedere {{jsxref("JSON.stringify()")}}.</p>

<h3 id="Symbol_wrapper_objects_come_chiavi_per_le_proprietà">Symbol wrapper objects come chiavi per le proprietà</h3>

<p>Quando un oggetto wrapper symbol viene usato come chiave di una proprietà, tale oggetto verrà costretto al suo wrapped symbol:</p>

<pre class="brush: js">var sym = Symbol('foo');
var obj = {[sym]: 1};
obj[sym];            // 1
obj[Object(sym)];    // still 1
</pre>

<h2 id="Specificazioni">Specificazioni</h2>

<table class="standard-table">
 <tbody>
  <tr>
   <th scope="col">Specificazione</th>
   <th scope="col">Stato</th>
   <th scope="col">Commento</th>
  </tr>
  <tr>
   <td>{{SpecName('ES2015', '#sec-symbol-objects', 'Symbol')}}</td>
   <td>{{Spec2('ES2015')}}</td>
   <td>Initial definition</td>
  </tr>
  <tr>
   <td>{{SpecName('ESDraft', '#sec-symbol-objects', 'Symbol')}}</td>
   <td>{{Spec2('ESDraft')}}</td>
   <td> </td>
  </tr>
 </tbody>
</table>

<h2 id="Browser_compatibility">Browser compatibility</h2>



<p>{{Compat("javascript.builtins.Symbol")}}</p>

<h2 id="Vedere_anche">Vedere anche</h2>

<ul>
 <li><a href="/en-US/docs/Glossary/Symbol">Glossary: Symbol data type</a></li>
 <li>{{jsxref("Operators/typeof", "typeof")}}</li>
 <li><a href="/en-US/docs/Web/JavaScript/Data_structures">Data types and data structures</a></li>
 <li><a href="https://hacks.mozilla.org/2015/06/es6-in-depth-symbols/">"ES6 In Depth: Symbols" on hacks.mozilla.org</a></li>
</ul>