La AWS SDK per JavaScript v2 è arrivata. end-of-support [Ti consigliamo di migrare alla AWS SDK per JavaScript v3.](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/) [Per ulteriori dettagli e informazioni su come effettuare la migrazione, consulta questo annuncio.](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/) Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Chiamate asincrone dei servizi Tutte le richieste effettuate attraverso l'SDK sono asincrone. Questo è importante da tenere a mente quando si scrivono gli script del browser. JavaScript l'esecuzione in un browser Web in genere ha un solo thread di esecuzione. Dopo aver effettuato una chiamata asincrona a un AWS servizio, lo script del browser continua a essere eseguito e durante il processo può provare a eseguire il codice che dipende da quel risultato asincrono prima che venga restituito. L'esecuzione di chiamate asincrone a un AWS servizio include la gestione di tali chiamate in modo che il codice non tenti di utilizzare i dati prima che i dati siano disponibili. Gli argomenti di questa sezione spiegano la necessità di gestire le chiamate asincrone e illustrano diverse tecniche che è possibile utilizzare per gestirle. **Topics** + [Gestione delle chiamate asincrone](making-asynchronous-calls.md) + [Utilizzo di una funzione di callback anonimo](using-a-callback-function.md) + [Utilizzo di un listener di eventi oggetto di richiesta](using-a-response-event-handler.md) + [Utilizzo di async/await](using-async-await.md) + [Usare Promises JavaScript](using-promises.md) # Gestione delle chiamate asincrone Ad esempio, la home page di un sito Web di e-commerce consente l'accesso ai clienti registrati. Parte del vantaggio per i clienti che effettuano l'accesso è che, dopo l'accesso, il sito si adatta alle loro preferenze specifiche. Per fare in modo che ciò accada: 1. Il cliente deve accedere ed essere convalidato con le proprie credenziali di accesso. 1. Le preferenze del cliente vengono richieste da un database dei clienti. 1. Il database fornisce le preferenze del cliente che vengono utilizzate per personalizzare il sito prima che la pagina venga caricata. Se queste attività vengono eseguite in modo sincrono, ognuna deve terminare prima venga avviata quella successiva. La pagina Web non è in grado di completare il caricamento finché le preferenze del cliente non vengono restituite dal database. Tuttavia, dopo che la query del database viene inviata al server, la ricezione dei dati del cliente può essere posticipata o può addirittura fallire a causa di colli di bottiglia della rete, traffico di database eccezionalmente elevato o connessione scadente dei dispositivi mobili. Per impedire il congelamento del sito Web in tali condizioni, chiama il database in modo asincrono. Dopo l'esecuzione della chiamata al database, inviando la tua richiesta asincrona, il tuo codice continua a essere eseguito come previsto. Se non gestisci correttamente la risposta di una chiamata asincrona, il tuo codice può tentare di utilizzare le informazioni che si aspetta dal database quando tali dati non sono ancora disponibili. ![\[Differenza tra esecuzione sincrona e asincrona.\]](http://docs.aws.amazon.com/it_it/sdk-for-javascript/v2/developer-guide/images/async-vs-sync.png) # Utilizzo di una funzione di callback anonimo Ogni metodo dell'oggetto di servizio che crea un oggetto `AWS.Request` può accettare una funzione di callback anonimo come ultimo parametro. La firma di questa funzione di callback è: ``` function(error, data) { // callback handling code } ``` Questa funzione di callback viene eseguita quando vengono restituiti una risposta corretta o i dati dell'errore. Se la chiamata al metodo va a buon fine, i contenuti della risposta sono disponibili per la funzione di callback nel parametro `data`. Se la chiamata non va a buon fine, i dettagli sull'errore vengono forniti nel parametro `error`. In genere il codice all'interno della funzione di callback verifica un errore, che elabora nel caso venga restituito. Se non viene restituito un errore, il codice recupera i dati dalla risposta dal parametro `data`. Il formato di base della funzione di callback è simile al seguente esempio. ``` function(error, data) { if (error) { // error handling code console.log(error); } else { // data handling code console.log(data); } } ``` Nell'esempio precedente, i dettagli dell'errore o dei dati restituiti vengono registrati nella console. Ecco un esempio che mostra una funzione di callback trasferita come parte della chiamata a un metodo su un oggetto di servizio. ``` new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(function(error, data) { if (error) { console.log(error); // an error occurred } else { console.log(data); // request succeeded } }); ``` ## Accesso agli oggetti di richiesta e risposta All'interno della funzione di callback, la JavaScript parola chiave `this` si riferisce all'oggetto sottostante per la maggior parte dei servizi. `AWS.Response` Nell'esempio seguente, la proprietà `httpResponse` di un oggetto `AWS.Response` viene utilizzata all'interno di una funzione di callback per registrare i dati e le intestazioni della risposta non elaborati per facilitare il debug. ``` new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(function(error, data) { if (error) { console.log(error); // an error occurred // Using this keyword to access AWS.Response object and properties console.log("Response data and headers: " + JSON.stringify(this.httpResponse)); } else { console.log(data); // request succeeded } }); ``` Inoltre, poiché l'oggetto `AWS.Response` ha una proprietà `Request` che contiene l'oggetto `AWS.Request` inviato dalla chiamata al metodo originale, puoi accedere anche ai dettagli della richiesta effettuata. # Utilizzo di un listener di eventi oggetto di richiesta Se non crei e trasferisci una funzione di callback anonimo come parametro quando chiami un metodo dell'oggetto di servizio, la chiamata al metodo genera un oggetto `AWS.Request` che deve essere inviato manualmente utilizzando il relativo metodo `send`. Per elaborare la risposta, devi creare un listener di eventi per l'oggetto `AWS.Request` per registrare una funzione di callback per la chiamata al metodo. L'esempio seguente mostra come creare l'oggetto `AWS.Request` per chiamare un metodo dell'oggetto di servizio e il listener di eventi per l'esito positivo. ``` // create the AWS.Request object var request = new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(); // register a callback event handler request.on('success', function(response) { // log the successful data response console.log(response.data); }); // send the request request.send(); ``` Dopo aver chiamato il metodo `send` sul'oggetto `AWS.Request`, viene eseguito il gestore eventi quando l'oggetto di servizio riceve un oggetto `AWS.Response`. Per ulteriori informazioni sull'`AWS.Request`oggetto, consulta [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)l'API Reference. Per ulteriori informazioni sull'`AWS.Response`oggetto, consulta [Utilizzo dell'oggetto di risposta](the-response-object.md) o [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html)consulta l'API Reference. ## Concatenazione di più callback Puoi registrare più callback su qualsiasi oggetto di richiesta. È possibile registrare più callback per diversi eventi o per lo stesso evento. Puoi anche concatenare i callback come mostrato nell'esempio seguente. ``` request. on('success', function(response) { console.log("Success!"); }). on('error', function(response) { console.log("Error!"); }). on('complete', function() { console.log("Always!"); }). send(); ``` ## Eventi di completamento degli oggetti di richiesta L'oggetto `AWS.Request` genera questi eventi di completamento in base alla risposta di ciascun metodo dell'operazione di servizio: + `success` + `error` + `complete` Puoi registrarsi una funzione di callback in risposta a uno qualsiasi di questi eventi. Per un elenco completo di tutti gli eventi relativi all'oggetto della richiesta, [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)consulta l'API Reference. ### Evento success L'evento `success` viene generato in seguito a una risposta positiva ricevuta dall'oggetto di servizio. Ecco come si registra una funzione di callback per questo evento. ``` request.on('success', function(response) { // event handler code }); ``` La risposta fornisce una proprietà `data` che contiene i dati di risposta serializzati dal servizio. Ad esempio, la seguente chiamata al `listBuckets` metodo dell'oggetto di servizio Amazon S3 ``` s3.listBuckets.on('success', function(response) { console.log(response.data); }).send(); ``` restituisce la risposta e quindi stampa i seguenti contenuti della proprietà `data` nella console. ``` { Owner: { ID: '...', DisplayName: '...' }, Buckets: [ { Name: 'someBucketName', CreationDate: someCreationDate }, { Name: 'otherBucketName', CreationDate: otherCreationDate } ], RequestId: '...' } ``` ### Evento error L'evento `error` viene generato in seguito a una risposta di errore ricevuta dall'oggetto di servizio. Ecco come si registra una funzione di callback per questo evento. ``` request.on('error', function(error, response) { // event handling code }); ``` Quando viene generato l'evento `error`, il valore della proprietà `data` della risposta è `null` e la proprietà `error` contiene i dati dell'errore. L'oggetto `error` associato viene trasferito come primo parametro alla funzione di callback registrata. Ad esempio, il seguente codice: ``` s3.config.credentials.accessKeyId = 'invalid'; s3.listBuckets().on('error', function(error, response) { console.log(error); }).send(); ``` restituisce l'errore e quindi stampa i seguenti dati dell'errore nella console. ``` { code: 'Forbidden', message: null } ``` ### Evento complete L'evento `complete` viene generato al termine della chiamata a un oggetto di servizio, indipendentemente dal fatto che la chiamata abbia esito positivo o negativo. Ecco come si registra una funzione di callback per questo evento. ``` request.on('complete', function(response) { // event handler code }); ``` Utilizza il callback dell'evento `complete` per gestire qualsiasi pulizia delle richieste che deve essere eseguita indipendentemente dall'esito positivo o negativo. Se utilizzi i dati di risposta all'interno di un callback per l'evento `complete`, verifica le proprietà `response.data` o `response.error` prima di tentare di accedervi, come mostrato nell'esempio seguente. ``` request.on('complete', function(response) { if (response.error) { // an error occurred, handle it } else { // we can use response.data here } }).send(); ``` ## Eventi HTTP degli oggetti di richiesta L'oggetto `AWS.Request` genera questi eventi HTTP in base alla risposta di ciascun metodo dell'operazione di servizio: + `httpHeaders` + `httpData` + `httpUploadProgress` + `httpDownloadProgress` + `httpError` + `httpDone` Puoi registrarsi una funzione di callback in risposta a uno qualsiasi di questi eventi. Per un elenco completo di tutti gli eventi relativi all'oggetto della richiesta, consulta [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)l'API Reference. ### Evento httpHeaders L'evento `httpHeaders` viene generato quando vengono inviate le intestazioni dal server remoto. Ecco come si registra una funzione di callback per questo evento. ``` request.on('httpHeaders', function(statusCode, headers, response) { // event handling code }); ``` Il parametro `statusCode` della funzione di callback è il codice di stato HTTP. Il parametro `headers` contiene le intestazioni di risposta. ### Evento httpData L'evento `httpData` viene generato per eseguire lo streaming dei pacchetti di dati di risposta dal servizio. Ecco come si registra una funzione di callback per questo evento. ``` request.on('httpData', function(chunk, response) { // event handling code }); ``` Questo evento viene in genere utilizzato per ricevere risposte di grandi dimensioni in blocchi quando il caricamento dell'intera risposta in memoria non è una soluzione pratica. Questo evento ha un parametro `chunk` aggiuntivo che contiene una parte dei dati effettivi dal server. Se registri un callback per l'evento `httpData`, la proprietà `data` della risposta contiene l'intero output serializzato per la richiesta. Devi rimuovere il listener `httpData` predefinito se non disponi dell'overhead di analisi e memoria extra per i gestori incorporati. ### Gli httpUploadProgress ed httpDownloadProgress eventi L'evento `httpUploadProgress` viene generato quando la richiesta HTTP ha caricato più dati. Allo stesso modo, l'evento `httpDownloadProgress` viene generato quando la richiesta HTTP ha scaricato più dati. Ecco come si registra una funzione di callback per questi eventi. ``` request.on('httpUploadProgress', function(progress, response) { // event handling code }) .on('httpDownloadProgress', function(progress, response) { // event handling code }); ``` Il parametro `progress` della funzione di callback contiene un oggetto con i byte caricati e totali della richiesta. ### Evento httpError L'evento `httpError` viene generato quando la richiesta HTTP ha esito negativo. Ecco come si registra una funzione di callback per questo evento. ``` request.on('httpError', function(error, response) { // event handling code }); ``` Il parametro `error` della funzione di callback contiene l'errore che è stato generato. ### Evento httpDone L'evento `httpDone` viene generato quando il server termina l'invio di dati. Ecco come si registra una funzione di callback per questo evento. ``` request.on('httpDone', function(response) { // event handling code }); ``` # Utilizzo di async/await È possibile utilizzare lo `async/await` schema nelle chiamate a AWS SDK per JavaScript. La maggior parte delle funzioni che accettano un callback non restituiscono una promessa. Poiché si utilizzano solo `await` funzioni che restituiscono una promessa, per utilizzare lo `async/await` schema è necessario concatenare il `.promise()` metodo alla fine della chiamata e rimuovere il callback. L'esempio seguente utilizza async/await per elencare tutte le tabelle Amazon DynamoDB in. `us-west-2` ``` var AWS = require("aws-sdk"); //Create an Amazon DynamoDB client service object. dbClient = new AWS.DynamoDB({ region: "us-west-2" }); // Call DynamoDB to list existing tables const run = async () => { try { const results = await dbClient.listTables({}).promise(); console.log(results.TableNames.join("\n")); } catch (err) { console.error(err); } }; run(); ``` **Nota** Non tutti i browser supportano async/await. Vedi [Funzioni asincrone](https://caniuse.com/#feat=async-functions) per un elenco di browser supportati. async/await # Usare Promises JavaScript Il metodo `AWS.Request.promise` fornisce un modo per chiamare un'operazione di servizio e gestire il flusso asincrono invece di utilizzare i callback. In Node.js e negli script del browser, viene restituito un oggetto `AWS.Request` quando viene chiamata un'operazione di servizio senza una funzione di callback. Puoi chiamare il metodo `send` della richiesta per effettuare la chiamata di servizio. Tuttavia, `AWS.Request.promise` avvia immediatamente la chiamata di servizio e restituisce una promessa soddisfatta con la proprietà `data` della risposta o respinta con la proprietà `error` della risposta. ``` var request = new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(); // create the promise object var promise = request.promise(); // handle promise's fulfilled/rejected states promise.then( function(data) { /* process the data */ }, function(error) { /* handle the error */ } ); ``` L'esempio seguente restituisce una promessa soddisfatta con un oggetto `data` o respinta con un oggetto `error`. Utilizzando le promesse, un singolo callback non è responsabile per il rilevamento degli errori. Al contrario, il callback corretto viene chiamato in base all'esito positivo o negativo di una richiesta. ``` var s3 = new AWS.S3({apiVersion: '2006-03-01', region: 'us-west-2'}); var params = { Bucket: 'bucket', Key: 'example2.txt', Body: 'Uploaded text using the promise-based method!' }; var putObjectPromise = s3.putObject(params).promise(); putObjectPromise.then(function(data) { console.log('Success'); }).catch(function(err) { console.log(err); }); ``` ## Coordinamento di più promesse In alcune situazioni, il tuo codice deve effettuare più chiamate asincrone che richiedono un intervento solo quando sono state restituite tutte correttamente. Se gestisci tali chiamate singole al metodo asincrono con le promesse, puoi creare una promessa aggiuntiva che utilizza il metodo `all`. Questo metodo soddisfa questa promessa universale se e quando le promesse che trasferisci al metodo vengono soddisfatte. Alla funzione di callback viene trasferito una matrice dei valori delle promesse trasferite al metodo `all`. Nell'esempio seguente, una AWS Lambda funzione deve effettuare tre chiamate asincrone ad Amazon DynamoDB, ma può essere completata solo dopo aver soddisfatto le promesse per ogni chiamata. ``` Promise.all([firstPromise, secondPromise, thirdPromise]).then(function(values) { console.log("Value 0 is " + values[0].toString); console.log("Value 1 is " + values[1].toString); console.log("Value 2 is " + values[2].toString); // return the result to the caller of the Lambda function callback(null, values); }); ``` ## Supporto del browser e di Node.js per le promesse Il supporto per JavaScript le promesse native (ECMAScript 2015) dipende dal JavaScript motore e dalla versione in cui viene eseguito il codice. Per determinare il supporto per le JavaScript promesse in ogni ambiente in cui il codice deve essere eseguito, consulta la [Tabella ECMAScript di compatibilità](https://compat-table.github.io/compat-table/es6/) su. GitHub ## Utilizzo di altre implementazioni di promesse Oltre all'implementazione nativa di Promise nel ECMAScript 2015, puoi anche utilizzare librerie di promesse di terze parti, tra cui: + [bluebird](http://bluebirdjs.com) + [RSVP](https://github.com/tildeio/rsvp.js/) + [Q](https://github.com/kriskowal/q) Queste librerie di promesse opzionali possono essere utili se hai bisogno che il codice venga eseguito in ambienti che non supportano l'implementazione nativa di promise nel ECMAScript 5 e nel ECMAScript 2015. Per utilizzare una libreria di promesse di terze parti, imposta una dipendenza per le promesse sull'SDK chiamando il metodo `setPromisesDependency` dell'oggetto di configurazione globale. Negli script del browser, assicurati di caricare la libreria di promesse di terze parti prima di caricare l'SDK. Nell'esempio seguente, l'SDK è configurato per utilizzare l'implementazione nella libreria di promesse bluebird. ``` AWS.config.setPromisesDependency(require('bluebird')); ``` Per tornare a utilizzare l'implementazione nativa di promise del JavaScript motore, `setPromisesDependency` richiama, passando un nome di libreria `null` anziché un nome di libreria.