From 95aca4b4d8fa62815d4bd412fff1a364f842814a Mon Sep 17 00:00:00 2001 From: Ryan Johnson Date: Thu, 29 Apr 2021 16:16:42 -0700 Subject: remove retired locales (#699) --- .../global_objects/promise/all/index.html | 110 --------- .../global_objects/promise/catch/index.html | 124 ----------- .../reference/global_objects/promise/index.html | 248 --------------------- 3 files changed, 482 deletions(-) delete mode 100644 files/it/web/javascript/reference/global_objects/promise/all/index.html delete mode 100644 files/it/web/javascript/reference/global_objects/promise/catch/index.html delete mode 100644 files/it/web/javascript/reference/global_objects/promise/index.html (limited to 'files/it/web/javascript/reference/global_objects/promise') 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 ---- -
{{JSRef}}
- -

Il metodo Promise.all(iterable) 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.

- -

Sintassi

- -
Promise.all(iterable);
- -

Parameteri

- -
-
iterable
-
Un oggetto iterabile, come un {{jsxref("Array")}}. See iterable.
-
- -

Valore di ritorno

- -

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

- -

Descrizione

- -

Il metodo Promise.all 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")}}. 

- -

Se uno qualsiasi dei promise passati viene rigettato, il metodo all 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.

- -

Esempi

- -

Usare Promise.all

- -

Il metodo Promise.all aspetta la risoluzione di tutti i promise  (od il primo che viene rigettato).

- -
var p1 = Promise.resolve(3);
-var p2 = 1337;
-var p3 = new Promise((resolve, reject) => {
-  setTimeout(resolve, 100, "foo");
-});
-
-Promise.all([p1, p2, p3]).then(values => {
-  console.log(values); // [3, 1337, "foo"]
-});
- -

Promise.all comportamento fail-fast

- -

Il metodo Promise.all viene rigettato se uno degli elementi viene rigettato e Promise.all viene rigettato immediatamente. In caso quattro promise vengono risolti dopo un  timeout, e uno viene rigettato immediatamente: allora Promise.all viene rigettato immediamente.

- -
var p1 = new Promise((resolve, reject) => {
-  setTimeout(resolve, 1000, "one");
-});
-var p2 = new Promise((resolve, reject) => {
-  setTimeout(resolve, 2000, "two");
-});
-var p3 = new Promise((resolve, reject) => {
-  setTimeout(resolve, 3000, "three");
-});
-var p4 = new Promise((resolve, reject) => {
-  setTimeout(resolve, 4000, "four");
-});
-var p5 = new Promise((resolve, reject) => {
-  reject("reject");
-});
-
-Promise.all([p1, p2, p3, p4, p5]).then(value => {
-  console.log(value);
-}, reason => {
-  console.log(reason)
-});
-
-//From console:
-//"reject"
-
- -

Specifiche

- - - - - - - - - - - - - - - - - - - -
SpecificheStatusCommenti
{{SpecName('ES6', '#sec-promise.all', 'Promise.all')}}{{Spec2('ES6')}}Definizione iniziale nello standard ECMA.
{{SpecName('ESDraft', '#sec-promise.all', 'Promise.all')}}{{Spec2('ESDraft')}} 
- -

Compatibilitá dei browser

- - - -

{{Compat}}

- -

Vedi anche

- - 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 ---- -
{{JSRef}}
- -

Il metodo catch() restituisce una Promise e si occusa esclusivamente nei casi respinti. Si comporta come una chiamata {{jsxref("Promise.then", "Promise.prototype.then(undefined, onRejected)")}}.

- -

 

- -

Sintassi

- -
p.catch(onRejected);
-
-p.catch(function(reason) {
-   // rejection
-});
-
- -

Parametri

- -
-
onRejected
-
Una {{jsxref("Function")}} chiamata quando la Promise viene respinta. Questa funzione richiede un parametro, la motivazione della respinta.
-
- -

Descrizione

- -

Il metodo catch può essere utile per gestire errori nella composizione delle promise.

- -

Esempi

- -

Uso del metodo catch

- -
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!"
-});
-
- -

Specifications

- - - - - - - - - - - - - - -
SpecificationStatusComment
{{SpecName('ES6', '#sec-promise.prototype.catch', 'Promise.prototype.catch')}}{{Spec2('ES6')}}Initial definition in an ECMA standard.
- -

Browser compatibility

- -

{{CompatibilityTable}}

- -
- - - - - - - - - - - - - - - - - - - -
FeatureChromeFirefox (Gecko)Internet ExplorerOperaSafari
Basic support32{{CompatGeckoDesktop(29.0)}} [1]{{CompatNo}}197.1
-
- -
- - - - - - - - - - - - - - - - - - - - - -
FeatureAndroidFirefox Mobile (Gecko)IE MobileOpera MobileSafari MobileChrome for Android
Basic support{{CompatNo}}{{CompatGeckoMobile(29.0)}} [1]{{CompatNo}}{{CompatNo}}832
-
- -

[1] Gecko 24 has an experimental implementation of Promise, under the initial name of Future. It got renamed to its final name in Gecko 25, but disabled by default behind the flag dom.promise.enabled. Bug 918806 enabled Promises by default in Gecko 29.

- -

See also

- - 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 ---- -
{{JSRef}}
- -

Gli oggetti Promise sono usati per computazioni in differita e asincrone. Una Promise rappresenta un'operazione che non è ancora completata, ma lo sarà in futuro.

- -

Sintassi

- -
new Promise(function(resolve, reject) { ... });
- -

Parametri

- -
-
executor
-
-

Una funzione che ha due argomenti: resolve e reject.  Tale funzione viene chiamata immediatamente dall'implementazione della Promise, passando i due argomenti resolve e reject, che sono due funzioni. Le due funzioni resolve e reject, quando chiamate, risolvono o rigettano la promise. L'esecutore inizia del lavoro (solitamente asincrono), e, una volta completato, chiama resolve per risolvere la promise, o reject se c'è stato qualche errore. Se un errore viene sollevato nella funzione di esecuzione (executor) la promise viene rigettata.

-
-
- -

Descrizione

- -

Una Promise 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 promise, tramite la quale si potrà ottenere il valore di completamento una volta che la promise sarà terminata.

- -

Una Promise può presentarsi in uno dei seguenti stati:

- - - -

Una promise in pending può evolvere sia in fulfilled con un valore, sia in rejected con una motivazione (errore). Quando accade una di queste situazioni, vengono chiamati gli handler associati che sono stati accodati dal metodo then 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).

- -

Poichè i metodi {{jsxref("Promise.then", "Promise.prototype.then")}} e {{jsxref("Promise.catch", "Promise.prototype.catch")}} restituiscono delle promise, è possibile concatenarli tramite l'operazione di composition.

- -

- -
-

Da non confondere con: 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 arrow function senza argomenti: f = () => expression per creare un'espressione non valutata immediatamente (lazy-evaluated) ed usare f() per valutarla.

-
- -
-

Nota: Si dice che una promise è "ferma" (settled) se è soddisfatta o respinta, ma non in pending. Si può parlare anche di promessa "risolta" (resolved) quando la promise è ferma o è bloccata in una catena di promise. States and fates di Domenic Denicola contiene maggiori dettagli sulla terminologia riguardo le promise.

-
- -

Proprietà

- -
-
Promise.length
-
La proprietà length (lunghezza) ha come valore 1 (numero di argomenti del costruttore).
-
{{jsxref("Promise.prototype")}}
-
Rappresenta il prototype per il costruttore della Promise.
-
- -

Metodi

- -
-
{{jsxref("Promise.all", "Promise.all(iterable)")}}
-
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 Iterable 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.
-
{{jsxref("Promise.race", "Promise.race(iterable)")}}
-
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.
-
- -
-
{{jsxref("Promise.reject", "Promise.reject(reason)")}}
-
Restituisce un oggetto Promise che è respinta con la data motivazione.
-
- -
-
{{jsxref("Promise.resolve", "Promise.resolve(value)")}}
-
Restituise un oggetto Promise che è risolto con il valore dato. Se il valore é un thenable (es. ha un metodo then), 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.
-
- -

Promise prototype

- -

Proprietà

- -

{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Properties')}}

- -

Metodi

- -

{{page('en-US/Web/JavaScript/Reference/Global_Objects/Promise/prototype','Methods')}}

- -

Creazione di una Promise

- -

Un oggetto di tipo Promise, viene creato con la keyowrd new ed il suo costruttore. Questo costruttore accetta come argomento una funzione, chiamata "funzione esecutore (executor function)". Questa funzione accetta altre due funzioni come parametri. La prima (resolve) viene eseguita in modo asincrono quando l'operazione viene eseguita con successo e restituisce il risultato dell'operazione come valore. La seconda (reject) 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 Error

- -
const myFirstPromise = new Promise((resolve, reject) => {
-  // esegue qualcosa di asincrono che eventualmente chiama:
-  //
-     resolve(someValue); // fulfilled
-  // oppure
-     reject("motivo del fallimento"); // rejected
-});
- -

Per creare una funzione con il comportamento di Promise, semplicemente restituisci una promise

- -
function myAsyncFunction(url) {
-  return new Promise((resolve, reject) => {
-    const xhr = new XMLHttpRequest();
-    xhr.open("GET", url);
-    xhr.onload = () => resolve(xhr.responseText);
-    xhr.onerror = () => reject(xhr.statusText);
-    xhr.send();
-  });
-}
- -

Esempi

- -

Esempio semplice

- -
let myFirstPromise = new Promise((resolve, reject) => {
-  // 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) => {
-  // 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);
-});
- -

Esempio avanzato

- -
<button id="btn">Make a promise!</button>
-<div id="log"></div>
- -

Questo piccolo esempio mostra il meccanismo delle Promise. Il metodo testPromise() 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 Promise viene utilizzato per creare la promise.

- -

La risoluzione della promise viene semplicemente loggata tramite una funzione di callback fulfill {{jsxref("Promise.prototype.then()","p1.then()")}}. Una serie di log mostrano che il comportamento sincrono del metodo è disaccoppiato rispetto all'esecuzione asincrona della promise.

- -
'use strict';
-var promiseCount = 0;
-
-function testPromise() {
-    let thisPromiseCount = ++promiseCount;
-
-    let log = document.getElementById('log');
-    log.insertAdjacentHTML('beforeend', thisPromiseCount +
-        ') Started (<small>Sync code started</small>)<br/>');
-
-    // 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) => {
-            log.insertAdjacentHTML('beforeend', thisPromiseCount +
-                ') Promise started (<small>Async code started</small>)<br/>');
-            // 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 (<small>Async code terminated</small>)<br/>');
-        }).catch(
-        // Log the rejection reason
-       (reason) => {
-            console.log('Handle rejected promise ('+reason+') here.');
-        });
-
-    log.insertAdjacentHTML('beforeend', thisPromiseCount +
-        ') Promise made (<small>Sync code terminated</small>)<br/>');
-}
-
-
-
-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 <code>Promise<code> interface.";
-}
- -

In questo esempio si comincia cliccando il bottone. Per testare necessiti di un browser che supporta le Promise. Cliccando il bottone diverse volte in un lasso di tempo breve vedrai che le funzioni verranno risolte una dopo l'altra.

- -

Caricare un'immagine con XHR

- -

Un'altro semplice esempio che utilizza le Promise e XMLHttpRequest mostra come caricare un'immagine è disponibile sul repository 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.

- -

Specifiche

- - - - - - - - - - - - - - - - - - - -
SpecificaStatoCommento
{{SpecName('ES2015', '#sec-promise-objects', 'Promise')}}{{Spec2('ES2015')}} -

Prima definizione in uno standard ECMA.

-
{{SpecName('ESDraft', '#sec-promise-objects', 'Promise')}}{{Spec2('ESDraft')}} -

 

-
- -

Supporto dei browser

- -

{{Compat("javascript.builtins.Promise")}}

- -

Vedi anche

- - -- cgit v1.2.3-54-g00ecf