La [AWS SDK per JavaScript V3 API Reference Guide](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) descrive in dettaglio tutte le operazioni API per la AWS SDK per JavaScript versione 3 (V3). 

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à.

# Chiama i servizi in modo asincrono
<a name="calling-services-asynchronously"></a>

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.

Sebbene sia possibile utilizzare una qualsiasi di queste tecniche per gestire le chiamate asincrone, si consiglia di utilizzarla per tutto il nuovo codice. async/await 

async/await  
Si consiglia di utilizzare questa tecnica in quanto è il comportamento predefinito in V3.

promettere  
Usa questa tecnica nei browser che non supportano async/await.

richiamata  
Evita di usare i callback tranne in casi molto semplici. Tuttavia, potresti trovarlo utile per gli scenari di migrazione.

**Topics**
+ [Gestisci le chiamate asincrone](making-asynchronous-calls.md)
+ [Usa async/await](using-async-await.md)
+ [Usa le promesse JavaScript](using-promises.md)
+ [Usa una funzione di callback anonima](using-a-callback-function.md)

# Gestisci le chiamate asincrone
<a name="making-asynchronous-calls"></a>

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. Il caricamento della pagina web non potrà essere completato finché le preferenze del cliente non torneranno 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 evitare che il sito Web si blocchi 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/v3/developer-guide/images/async-vs-sync.png)


# Usa async/await
<a name="using-async-await"></a>

Piuttosto che usare le promesse, dovresti considerare l'uso di async/await. Le funzioni asincrone sono più semplici e richiedono meno boilerplate rispetto all'uso delle promesse. Await può essere utilizzato solo in una funzione asincrona per attendere in modo asincrono un valore.

L'esempio seguente utilizza async/await per elencare tutte le tabelle Amazon DynamoDB in. ` us-west-2`

**Nota**  
Per eseguire questo esempio:  
Installa il client AWS SDK per JavaScript DynamoDB `npm install @aws-sdk/client-dynamodb` entrando nella riga di comando del tuo progetto.
Assicurati di aver configurato correttamente le tue AWS credenziali. Per ulteriori informazioni, consulta [Imposta le credenziali](setting-credentials.md). 

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";
(async function () {
  const dbClient = new DynamoDBClient({ region: "us-west-2" });
  const command = new ListTablesCommand({});

  try {
    const results = await dbClient.send(command);
    console.log(results.TableNames.join('\n'));
  } catch (err) {
    console.error(err)
  }
})();
```

**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 

# Usa le promesse JavaScript
<a name="using-promises"></a>

Utilizza il metodo AWS SDK per JavaScript v3 (`ListTablesCommand`) del client di servizio per effettuare la chiamata di servizio e gestire il flusso asincrono invece di utilizzare i callback. L'esempio seguente mostra come inserire i nomi delle tabelle Amazon DynamoDB. `us-west-2`

```
import {
  DynamoDBClient,
  ListTablesCommand
} from "@aws-sdk/client-dynamodb";
const dbClient = new DynamoDBClient({ region: 'us-west-2' });

dbClient.listtables(new ListTablesCommand({}))
  .then(response => {
    console.log(response.TableNames.join('\n'));
  })
  .catch((error) => {
    console.error(error);
  });
```

## Coordina più promesse
<a name="multiple-promises"></a>

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.

```
const values = await Promise.all([firstPromise, secondPromise, thirdPromise]);

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 values;
```

## Browser e Node.js supportano le promesse
<a name="browser-node-promise-support"></a>

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 di ECMAScript compatibilità](https://compat-table.github.io/compat-table/es6/) su GitHub.

# Usa una funzione di callback anonima
<a name="using-a-callback-function"></a>

Ogni metodo dell'oggetto di servizio può accettare una funzione di callback anonima come ultimo parametro. La firma di questa funzione di callback è la seguente.

```
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.

```
ec2.describeInstances(function(error, data) {
  if (error) {
    console.log(error); // an error occurred
  } else {
    console.log(data); // request succeeded
  }
});
```