remove retired locales (#699)

3 files changed, 0 insertions, 482 deletions

diff --git a/files/it/web/javascript/reference/global_objects/promise/all/index.html b/files/it/web/javascript/reference/global_objects/promise/all/index.html
deleted file mode 100644
index 4d1c9a970c..0000000000
--- a/files/it/web/javascript/reference/global_objects/promise/all/index.html
+++ /dev/null
@@ -1,110 +0,0 @@
----
-title: Promise.all()
-slug: Web/JavaScript/Reference/Global_Objects/Promise/all
-translation_of: Web/JavaScript/Reference/Global_Objects/Promise/all
----
-<div>{{JSRef}}</div>
-
-<p>Il metodo <code><strong>Promise.all(iterable)</strong></code> restituisce una singola promise che viene risolta quando tutte le promise nell'iterable passate come parametro vengono risolte. Scatena una reject contenente la ragione della prima promise che viene respinta.</p>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="syntaxbox"><var>Promise.all(iterable)</var>;</pre>
-
-<h3 id="Parameteri">Parameteri</h3>
-
-<dl>
- <dt>iterable</dt>
- <dd>Un oggetto iterabile, come un {{jsxref("Array")}}. See <a href="/en-US/docs/Web/JavaScript/Guide/iterable">iterable</a>.</dd>
-</dl>
-
-<h3 id="Valore_di_ritorno">Valore di ritorno</h3>
-
-<p>Un {{jsxref("Promise")}} che viene risolto quando tutti i promise nell'iterable passato come parametro vengono risolti, o scatena una reject contenente la ragione del primo promise che viene rigettato</p>
-
-<h2 id="Descrizione">Descrizione</h2>
-
-<p>Il metodo <strong>Promise.all </strong>ritorna un array di valori ritornati dai promise nell oggetto iterable che ha ricevuto. L'array dei valori ritornati mantiene lo stesso ordine dell'oggetto iterable originario e non l'ordine di risoluzione dei promise. Se uno dei valori dell'oggetto iterabile passato come parametro non un promise viene automaticamente convertito con {{jsxref("Promise.resolve")}}. </p>
-
-<p>Se uno qualsiasi dei promise passati viene rigettato, il metodo <code>all</code> Promise viene rigettato automaticamente con il valore del promise rigettato, scartando tutti i promise indipendentemente dal fatto che gli altri siano stati risolti o meno. Se viene passato un un array vuoto, allora questo metodo ritorna immediatamente.</p>
-
-<h2 id="Esempi">Esempi</h2>
-
-<h3 id="Usare_Promise.all">Usare <code>Promise.all</code></h3>
-
-<p><code>Il metodo Promise.all</code> aspetta la risoluzione di tutti i promise  (od il primo che viene rigettato).</p>
-
-<pre class="brush: js">var p1 = Promise.resolve(3);
-var p2 = 1337;
-var p3 = new Promise((resolve, reject) =&gt; {
-  setTimeout(resolve, 100, "foo");
-});
-
-Promise.all([p1, p2, p3]).then(values =&gt; {
-  console.log(values); // [3, 1337, "foo"]
-});</pre>
-
-<h3 id="Promise.all_comportamento_fail-fast"><code>Promise.all</code> comportamento fail-fast</h3>
-
-<p>Il metodo <code>Promise.all</code> viene rigettato se uno degli elementi viene rigettato e <code>Promise.all</code> viene rigettato immediatamente. In caso quattro promise vengono risolti dopo un  timeout, e uno viene rigettato immediatamente: allora <code>Promise.all</code> viene rigettato immediamente.</p>
-
-<pre class="brush: js">var p1 = new Promise((resolve, reject) =&gt; {
-  setTimeout(resolve, 1000, "one");
-});
-var p2 = new Promise((resolve, reject) =&gt; {
-  setTimeout(resolve, 2000, "two");
-});
-var p3 = new Promise((resolve, reject) =&gt; {
-  setTimeout(resolve, 3000, "three");
-});
-var p4 = new Promise((resolve, reject) =&gt; {
-  setTimeout(resolve, 4000, "four");
-});
-var p5 = new Promise((resolve, reject) =&gt; {
-  reject("reject");
-});
-
-Promise.all([p1, p2, p3, p4, p5]).then(value =&gt; {
-  console.log(value);
-}, reason =&gt; {
-  console.log(reason)
-});
-
-//From console:
-//"reject"
-</pre>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specifiche</th>
-   <th scope="col">Status</th>
-   <th scope="col">Commenti</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-promise.all', 'Promise.all')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Definizione iniziale nello standard ECMA.</td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-promise.all', 'Promise.all')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td> </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Compatibilitá_dei_browser">Compatibilitá dei browser</h2>
-
-<p class="hidden">To contribute to this compatibility data, please write a pull request against this file: <a href="https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json">https://github.com/mdn/browser-compat-data/blob/master/javascript/promise.json</a>.</p>
-
-<p>{{Compat}}</p>
-
-<h2 id="Vedi_anche">Vedi anche</h2>
-
-<ul>
- <li>{{jsxref("Promise")}}</li>
- <li>{{jsxref("Promise.race()")}}</li>
-</ul>
diff --git a/files/it/web/javascript/reference/global_objects/promise/catch/index.html b/files/it/web/javascript/reference/global_objects/promise/catch/index.html
deleted file mode 100644
index 0b9b906153..0000000000
--- a/files/it/web/javascript/reference/global_objects/promise/catch/index.html
+++ /dev/null
@@ -1,124 +0,0 @@
----
-title: Promise.prototype.catch()
-slug: Web/JavaScript/Reference/Global_Objects/Promise/catch
-translation_of: Web/JavaScript/Reference/Global_Objects/Promise/catch
----
-<div>{{JSRef}}</div>
-
-<p>Il metodo <strong>catch()</strong> restituisce una <code>Promise</code> e si occusa esclusivamente nei casi respinti. Si comporta come una chiamata {{jsxref("Promise.then", "Promise.prototype.then(undefined, onRejected)")}}.</p>
-
-<p> </p>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="syntaxbox"><var>p.catch(onRejected)</var>;
-
-p.catch(function(reason) {
-   // rejection
-});
-</pre>
-
-<h3 id="Parametri">Parametri</h3>
-
-<dl>
- <dt>onRejected</dt>
- <dd>Una {{jsxref("Function")}} chiamata quando la <code>Promise</code> viene respinta. Questa funzione richiede un parametro, la motivazione della respinta.</dd>
-</dl>
-
-<h2 id="Descrizione">Descrizione</h2>
-
-<p>Il metodo <code>catch</code> può essere utile per gestire errori nella composizione delle promise.</p>
-
-<h2 id="Esempi">Esempi</h2>
-
-<h3 id="Uso_del_metodo_catch">Uso del metodo catch</h3>
-
-<pre class="brush: js">var p1 = new Promise(function(resolve, reject) {
-  resolve("Success");
-});
-
-p1.then(function(value) {
-  console.log(value); // "Success!"
-  throw "oh, no!";
-}).catch(function(e) {
-  console.log(e); // "oh, no!"
-});
-</pre>
-
-<h2 id="Specifications">Specifications</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specification</th>
-   <th scope="col">Status</th>
-   <th scope="col">Comment</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES6', '#sec-promise.prototype.catch', 'Promise.prototype.catch')}}</td>
-   <td>{{Spec2('ES6')}}</td>
-   <td>Initial definition in an ECMA standard.</td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Browser_compatibility">Browser compatibility</h2>
-
-<p>{{CompatibilityTable}}</p>
-
-<div id="compat-desktop">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Chrome</th>
-   <th>Firefox (Gecko)</th>
-   <th>Internet Explorer</th>
-   <th>Opera</th>
-   <th>Safari</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>32</td>
-   <td>{{CompatGeckoDesktop(29.0)}} [1]</td>
-   <td>{{CompatNo}}</td>
-   <td>19</td>
-   <td>7.1</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<div id="compat-mobile">
-<table class="compat-table">
- <tbody>
-  <tr>
-   <th>Feature</th>
-   <th>Android</th>
-   <th>Firefox Mobile (Gecko)</th>
-   <th>IE Mobile</th>
-   <th>Opera Mobile</th>
-   <th>Safari Mobile</th>
-   <th>Chrome for Android</th>
-  </tr>
-  <tr>
-   <td>Basic support</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatGeckoMobile(29.0)}} [1]</td>
-   <td>{{CompatNo}}</td>
-   <td>{{CompatNo}}</td>
-   <td>8</td>
-   <td>32</td>
-  </tr>
- </tbody>
-</table>
-</div>
-
-<p>[1] Gecko 24 has an experimental implementation of <code>Promise</code>, under the initial name of <code>Future</code>. It got renamed to its final name in Gecko 25, but disabled by default behind the flag <code>dom.promise.enabled</code>. <a href="https://bugzilla.mozilla.org/show_bug.cgi?id=918806">Bug 918806</a> enabled Promises by default in Gecko 29.</p>
-
-<h2 id="See_also">See also</h2>
-
-<ul>
- <li>{{jsxref("Promise")}}</li>
- <li>{{jsxref("Promise.prototype.then()")}}</li>
-</ul>
diff --git a/files/it/web/javascript/reference/global_objects/promise/index.html b/files/it/web/javascript/reference/global_objects/promise/index.html
deleted file mode 100644
index d2f579bc51..0000000000
--- a/files/it/web/javascript/reference/global_objects/promise/index.html
+++ /dev/null
@@ -1,248 +0,0 @@
----
-title: Promise
-slug: Web/JavaScript/Reference/Global_Objects/Promise
-tags:
-  - ECMAScript 2015
-  - JavaScript
-  - Promise
-  - async
-translation_of: Web/JavaScript/Reference/Global_Objects/Promise
----
-<div>{{JSRef}}</div>
-
-<p>Gli oggetti <strong><code>Promise</code></strong> sono usati per computazioni in differita e asincrone. Una <code>Promise</code> rappresenta un'operazione che non è ancora completata, ma lo sarà in futuro.</p>
-
-<h2 id="Sintassi">Sintassi</h2>
-
-<pre class="brush: js">new Promise(function(resolve, reject) { ... });</pre>
-
-<h3 id="Parametri">Parametri</h3>
-
-<dl>
- <dt>executor</dt>
- <dd>
- <p>Una funzione che ha due argomenti: <code>resolve</code> e <code>reject</code>.  Tale funzione viene chiamata immediatamente dall'implementazione della Promise, passando i due argomenti <code>resolve</code> e <code>reject,</code> che sono due funzioni. Le due funzioni <code>resolve</code> e <code>reject</code>, quando chiamate, risolvono o rigettano la promise. L'esecutore inizia del lavoro (solitamente asincrono), e, una volta completato, chiama <code>resolve</code> per risolvere la promise, o <code>reject</code> se c'è stato qualche errore. Se un errore viene sollevato nella funzione di esecuzione <code>(executor)</code> la promise viene rigettata.</p>
- </dd>
-</dl>
-
-<h2 id="Descrizione">Descrizione</h2>
-
-<p>Una <code><strong>Promise</strong></code> rappresenta un proxy per un valore non necessariamente noto quando la promise è stata creata.  Consente di associare degli handlers con il successo o il fallimento di un'azione asincrona  (e il "valore" in caso di successo, o la motivazione in caso di fallimento). Questo in pratica consente di utilizzare dei metodi asincroni di fatto come se fossero sincroni: la funzione che compie del lavoro asincrono non ritorna il valore di completamento ma ritorna una <em>promise</em>, tramite la quale si potrà ottenere il valore di completamento una volta che la promise sarà terminata.</p>
-
-<p>Una <code>Promise</code> può presentarsi in uno dei seguenti stati:</p>
-
-<ul>
- <li><em>pending </em>(attesa): stato iniziale, né soddisfatto né respinto.</li>
- <li><em>fulfilled </em>(soddisfatto): significa che l'operazione si è conclusa con sucesso.</li>
- <li><em>rejected</em> (respinto): significa che l'operazione à fallita.</li>
-</ul>
-
-<p>Una promise in <em>pending</em> può evolvere sia in <em>fulfilled </em>con un valore, sia in <em>rejected</em> con una motivazione (errore). Quando accade una di queste situazioni, vengono chiamati gli handler associati che sono stati accodati dal metodo <code>then</code> della promise. (Se la promise è già stata soddisfatta o respinta quando viene agganciato l'handler, quest'ultimo verrà chiamato immediatamente, quindi non è necessario che gli handler vengano agganciati prima del completamento dell'operazione asincrona).</p>
-
-<p><font face="Open Sans, Arial, sans-serif">Poichè i metodi </font><code>{{jsxref("Promise.then", "Promise.prototype.then")}}</code> e <code>{{jsxref("Promise.catch", "Promise.prototype.catch")}}</code> restituiscono delle promise, è possibile concatenarli tramite l'operazione di <em>composition</em>.</p>
-
-<p><img alt="" src="https://mdn.mozillademos.org/files/8633/promises.png"></p>
-
-<div class="note">
-<p><strong>Da non confondere con: </strong>molti altri linguaggi hanno meccanismi simili per la lazy evaluation ed il calcolo differito, che a loro volta vengono chiamati "promise" (es. Schemes). Le Promise in Javascript rappresentano un processo che è gia accaduto, che può essere concatenato con delle funzioni di callback. Se stai cercando di eseguire una lazy evaluation (valutazione non immediata) di un'espressione, considera l'utilizzo delle <a href="https://developer.mozilla.org/it/docs/Web/JavaScript/Reference/Functions_and_function_scope/Arrow_functions">arrow function</a> senza argomenti: <code>f = () =&gt; <em>expression</em></code> per creare un'espressione non valutata immediatamente (lazy-evaluated) ed usare <code>f()</code> per valutarla.</p>
-</div>
-
-<div class="note">
-<p><strong>Nota</strong>: Si dice che una promise è "ferma" (<em>settled) </em>se è soddisfatta o respinta, ma non in <em>pending</em>. Si può parlare anche di promessa "risolta" (<em>resolved</em>) quando la promise è ferma o è bloccata in una catena di promise. <a href="https://github.com/domenic/promises-unwrapping/blob/master/docs/states-and-fates.md">States and fates</a> di Domenic Denicola contiene maggiori dettagli sulla terminologia riguardo le promise.</p>
-</div>
-
-<h2 id="Proprietà">Proprietà</h2>
-
-<dl>
- <dt><code>Promise.length</code></dt>
- <dd>La proprietà length (lunghezza) ha come valore 1 (numero di argomenti del costruttore).</dd>
- <dt>{{jsxref("Promise.prototype")}}</dt>
- <dd>Rappresenta il prototype per il costruttore della <code>Promise</code>.</dd>
-</dl>
-
-<h2 id="Metodi">Metodi</h2>
-
-<dl>
- <dt>{{jsxref("Promise.all", "Promise.all(iterable)")}}</dt>
- <dd>Ritorna una promise che si risolve quando tutte le promises dell'argomento iterabile sono state risolte. Oppure, viene rigettato appena una promise dell'argomento di tipo <code>Iterable</code> viene rigettato. Se tutto va a buon fine, la promise viene completata con un array contenente i valori di completamento di ciascuna promise dell'iterable, nello stesso ordine di quello dell'iterable. In caso fallisca (cioè appena una prima promise dell'iterable fallisce), Promise.all viene rigettato con la ragione (errore) della prima promise che ha fallito. Questo è utile per aggregare insieme il risultato di più promises.</dd>
- <dt>{{jsxref("Promise.race", "Promise.race(iterable)")}}</dt>
- <dd>Restituisce una promise che si risolve o respinge, non appena una delle promises dell'iterable si risolve o respinge, con il valore o la motivazione da quella promise.</dd>
-</dl>
-
-<dl>
- <dt>{{jsxref("Promise.reject", "Promise.reject(reason)")}}</dt>
- <dd>Restituisce un oggetto <code>Promise</code> che è respinta con la data motivazione.</dd>
-</dl>
-
-<dl>
- <dt>{{jsxref("Promise.resolve", "Promise.resolve(value)")}}</dt>
- <dd>Restituise un oggetto <code>Promise</code> che è risolto con il valore dato. Se il valore é un thenable (es. ha un metodo <code>then</code>), la promise restituita "seguirà" quel thenable, usando il suo stato; altirmenti la promise restituita sarà soddisfatta con il valore. Generalmente, se non sei sicuro che un valore sia di tipo Promise usa {{jsxref("Promise.resolve", "Promise.resolve(value)")}} e lavora con il valore restituito dalla promise.</dd>
-</dl>
-
-<h2 id="Promise_prototype">Promise prototype</h2>
-
-<h3 id="Proprietà_2">Proprietà</h3>
-
-<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Properties')}}</p>
-
-<h3 id="Metodi_2">Metodi</h3>
-
-<p>{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Methods')}}</p>
-
-<h2 id="Creazione_di_una_Promise">Creazione di una Promise</h2>
-
-<p>Un oggetto di tipo <code>Promise</code>, viene creato con la keyowrd <code>new</code> ed il suo costruttore. Questo costruttore accetta come argomento una funzione, chiamata "<code>funzione esecutore (executor function)</code>". Questa funzione accetta altre due funzioni come parametri. La prima (<code>resolve</code>) viene eseguita in modo asincrono quando l'operazione viene eseguita con successo e restituisce il risultato dell'operazione come valore. La seconda (<code>reject</code>) viene eseguita nel caso in cui l'operazione fallisca e restituisce il motivo per cui l'operazione non è stata eseguita: generalmente un oggetto di tipo <code>Error</code></p>
-
-<pre class="brush: js" dir="rtl">const myFirstPromise = new Promise((resolve, reject) =&gt; {
-  // esegue qualcosa di asincrono che eventualmente chiama:
-  //
-     resolve(someValue); // fulfilled
-  // oppure
-     reject("motivo del fallimento"); // rejected
-});</pre>
-
-<p>Per creare una funzione con il comportamento di Promise, semplicemente restituisci una promise</p>
-
-<pre class="brush: js">function myAsyncFunction(url) {
-  return new Promise((resolve, reject) =&gt; {
-    const xhr = new XMLHttpRequest();
-    xhr.open("GET", url);
-    xhr.onload = () =&gt; resolve(xhr.responseText);
-    xhr.onerror = () =&gt; reject(xhr.statusText);
-    xhr.send();
-  });
-}</pre>
-
-<h2 id="Esempi">Esempi</h2>
-
-<h3 id="Esempio_semplice">Esempio semplice</h3>
-
-<pre class="brush: js">let myFirstPromise = new Promise((resolve, reject) =&gt; {
-  // Chiamiamo resolve(...) quando viene eseguito correttamente, e reject(...) quando fallisce.
-  // In questo esempio viene utilizzato setTimeout(...) per simulare un'operazione asincrona.
-  // Nella realtà probabilmente utilizzerai qualcosa del tipo XHR o HTML5 API.
-  setTimeout(function(){
-    resolve("Success!"); // È andato tutto perfettamente!
-  }, 250);
-});
-
-myFirstPromise.then((successMessage) =&gt; {
-  // successMessage viene passato alla funzione resolve(...) .
-  // Non deve essere necessariamente una stringa, ma nel caso sia solo un messaggio probabilmemte lo sarà.
-  console.log("Yay! " + successMessage);
-});</pre>
-
-<h3 id="Esempio_avanzato">Esempio avanzato</h3>
-
-<pre class="brush: html">&lt;button id="btn"&gt;Make a promise!&lt;/button&gt;
-&lt;div id="log"&gt;&lt;/div&gt;</pre>
-
-<p>Questo piccolo esempio mostra il meccanismo delle <code>Promise</code>. Il metodo <code>testPromise()</code> viene richiamato ogni volta che il {{HTMLElement("button")}} viene cliccato. Crea una promise che viene risolta correttamente (fulfilled), utilizzando {{domxref("window.setTimeout()")}} che incrementa il contatore ogni 1-3 secondi (random). Il costruttore <code>Promise</code> viene utilizzato per creare la promise.</p>
-
-<p>La risoluzione della promise viene semplicemente loggata tramite una funzione di callback <code>fulfill</code> {{jsxref("Promise.prototype.then()","p1.then()")}}. Una serie di log mostrano che il comportamento sincrono del metodo è disaccoppiato rispetto all'esecuzione asincrona della promise.</p>
-
-<pre class="brush: js">'use strict';
-var promiseCount = 0;
-
-function testPromise() {
-    let thisPromiseCount = ++promiseCount;
-
-    let log = document.getElementById('log');
-    log.insertAdjacentHTML('beforeend', thisPromiseCount +
-        ') Started (&lt;small&gt;Sync code started&lt;/small&gt;)&lt;br/&gt;');
-
-    // We make a new promise: we promise a numeric count of this promise, starting from 1 (after waiting 3s)
-    let p1 = new Promise(
-        // The resolver function is called with the ability to resolve or
-        // reject the promise
-       (resolve, reject) =&gt; {
-            log.insertAdjacentHTML('beforeend', thisPromiseCount +
-                ') Promise started (&lt;small&gt;Async code started&lt;/small&gt;)&lt;br/&gt;');
-            // This is only an example to create asynchronism
-            window.setTimeout(
-                function() {
-                    // We fulfill the promise !
-                    resolve(thisPromiseCount);
-                }, Math.random() * 2000 + 1000);
-        }
-    );
-
-    // We define what to do when the promise is resolved with the then() call,
-    // and what to do when the promise is rejected with the catch() call
-    p1.then(
-        // Log the fulfillment value
-        function(val) {
-            log.insertAdjacentHTML('beforeend', val +
-                ') Promise fulfilled (&lt;small&gt;Async code terminated&lt;/small&gt;)&lt;br/&gt;');
-        }).catch(
-        // Log the rejection reason
-       (reason) =&gt; {
-            console.log('Handle rejected promise ('+reason+') here.');
-        });
-
-    log.insertAdjacentHTML('beforeend', thisPromiseCount +
-        ') Promise made (&lt;small&gt;Sync code terminated&lt;/small&gt;)&lt;br/&gt;');
-}
-
-
-
-if ("Promise" in window) {
-  let btn = document.getElementById("btn");
-  btn.addEventListener("click",testPromise);
-} else {
-  log = document.getElementById('log');
-  log.innerHTML = "Live example not available as your browser doesn't support the &lt;code&gt;Promise&lt;code&gt; interface.";
-}</pre>
-
-<p>In questo esempio si comincia cliccando il bottone. Per testare necessiti di un browser che supporta le <code>Promise</code>. Cliccando il bottone diverse volte in un lasso di tempo breve vedrai che le funzioni verranno risolte una dopo l'altra.</p>
-
-<h2 id="Caricare_un'immagine_con_XHR">Caricare un'immagine con XHR</h2>
-
-<p>Un'altro semplice esempio che utilizza le Promise e <a href="https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest">XMLHttpRequest</a> mostra come caricare un'immagine è disponibile sul <a href="https://github.com/mdn/js-examples/tree/master/promises-test">repository</a> di MDN su Github. Puoi inoltre vederla in azione. Ogni azione è commentata e puoi seguire passo-passo come viene creata la Promise e gestita tramite XHR.</p>
-
-<h2 id="Specifiche">Specifiche</h2>
-
-<table class="standard-table">
- <tbody>
-  <tr>
-   <th scope="col">Specifica</th>
-   <th scope="col">Stato</th>
-   <th scope="col">Commento</th>
-  </tr>
-  <tr>
-   <td>{{SpecName('ES2015', '#sec-promise-objects', 'Promise')}}</td>
-   <td>{{Spec2('ES2015')}}</td>
-   <td>
-    <p>Prima definizione in uno standard ECMA.</p>
-   </td>
-  </tr>
-  <tr>
-   <td>{{SpecName('ESDraft', '#sec-promise-objects', 'Promise')}}</td>
-   <td>{{Spec2('ESDraft')}}</td>
-   <td>
-    <p> </p>
-   </td>
-  </tr>
- </tbody>
-</table>
-
-<h2 id="Supporto_dei_browser">Supporto dei browser</h2>
-
-<p>{{Compat("javascript.builtins.Promise")}}</p>
-
-<h2 id="Vedi_anche">Vedi anche</h2>
-
-<ul>
- <li><a href="https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Using_promises">Using promises</a></li>
- <li><a href="http://promisesaplus.com/">Promises/A+ specification</a></li>
- <li><a href="https://medium.com/@ramsunvtech/promises-of-promise-part-1-53f769245a53">Venkatraman.R - JS Promise (Part 1, Basics)</a></li>
- <li><a href="https://medium.com/@ramsunvtech/js-promise-part-2-q-js-when-js-and-rsvp-js-af596232525c#.dzlqh6ski">Venkatraman.R - JS Promise (Part 2 - Using Q.js, When.js and RSVP.js)</a></li>
- <li><a href="https://tech.io/playgrounds/11107/tools-for-promises-unittesting/introduction">Venkatraman.R - Tools for Promises Unit Testing</a></li>
- <li><a href="http://www.html5rocks.com/en/tutorials/es6/promises/">Jake Archibald: JavaScript Promises: There and Back Again</a></li>
- <li><a href="http://de.slideshare.net/domenicdenicola/callbacks-promises-and-coroutines-oh-my-the-evolution-of-asynchronicity-in-javascript">Domenic Denicola: Callbacks, Promises, and Coroutines – Asynchronous Programming Patterns in JavaScript</a></li>
- <li><a href="http://www.mattgreer.org/articles/promises-in-wicked-detail/">Matt Greer: JavaScript Promises ... In Wicked Detail</a></li>
- <li><a href="https://www.promisejs.org/">Forbes Lindesay: promisejs.org</a></li>
- <li><a href="https://github.com/jakearchibald/es6-promise/">Promise polyfill</a></li>
- <li><a href="https://www.udacity.com/course/javascript-promises--ud898">Udacity: JavaScript Promises</a></li>
- <li> </li>
-</ul>