Le [guide de référence de l'API AWS SDK pour JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) décrit en détail toutes les opérations de l'API pour la AWS SDK pour JavaScript version 3 (V3). 

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Appeler les services de manière asynchrone
<a name="calling-services-asynchronously"></a>

Toutes les demandes effectuées via le kit SDK sont asynchrones. Il est important de garder cela à l'esprit lorsque vous écrivez des scripts de navigateur. JavaScript l'exécution dans un navigateur Web ne comporte généralement qu'un seul thread d'exécution. Après avoir effectué un appel asynchrone à un AWS service, le script du navigateur continue de s'exécuter et peut ainsi essayer d'exécuter du code qui dépend de ce résultat asynchrone avant qu'il ne soit renvoyé.

Les appels asynchrones à un AWS service incluent la gestion de ces appels afin que votre code n'essaie pas d'utiliser des données avant qu'elles ne soient disponibles. Les rubriques de cette section expliquent pourquoi il est nécessaire de gérer les appels asynchrones et détaillent les différentes techniques de gestion disponibles.

Bien que vous puissiez utiliser n'importe laquelle de ces techniques pour gérer les appels asynchrones, nous vous recommandons de l'utiliser async/await pour tout nouveau code.

async/wait  
Nous vous recommandons d'utiliser cette technique car il s'agit du comportement par défaut dans la version 3.

promettre  
Utilisez cette technique dans les navigateurs qui ne prennent pas en charge le mode async/await.

rappel  
Évitez d'utiliser des rappels, sauf dans des cas très simples. Toutefois, cela peut vous être utile pour les scénarios de migration.

**Topics**
+ [Gérer les appels asynchrones](making-asynchronous-calls.md)
+ [Utiliser async/await](using-async-await.md)
+ [JavaScript Promesses d'utilisation](using-promises.md)
+ [Utiliser une fonction de rappel anonyme](using-a-callback-function.md)

# Gérer les appels asynchrones
<a name="making-asynchronous-calls"></a>

Par exemple, la page d'accueil d'un site e-commerce autorise le renvoi de la connexion des utilisateurs. Pour les clients qui se connectent, cela présente notamment l'avantage, après connexion, de disposer d'une personnalisation en fonction de leurs préférences. Pour cela :

1. Le client doit se connecter et être validé avec ses identifiants de connexion.

1. La demande des préférences du client est faite auprès d'une base de données client.

1. La base de données fournit les préférences du client qui sont utilisées pour personnaliser le site avant le chargement de la page.

Si ces tâches s'exécutent de façon synchrone, chaque tâche doit se terminer avant le démarrage de la suivante. Le chargement de la page Web ne pourra pas être terminé tant que les préférences du client ne seront pas renvoyées de la base de données. Cependant, une fois que la requête de base de données est envoyée au serveur, la réception des données client peut être retardée ou même échouer en raison d'un goulot d'étranglement, d'un trafic de base de données exceptionnellement dense ou d'une mauvaise connexion d'un appareil mobile.

Pour éviter que le site Web ne se bloque dans ces conditions, appelez la base de données de manière asynchrone. Après l'exécution de l'appel de base de données, si vous envoyez une demande asynchrone, votre code continue de s'exécuter comme prévu. Si vous ne gérez pas correctement la réponse d'un appel asynchrone, votre code peut tenter d'utiliser les informations attendues de la base de données alors que ces données ne sont pas encore disponibles.

![\[Différence entre une exécution synchrone et une exécution asynchrone.\]](http://docs.aws.amazon.com/fr_fr/sdk-for-javascript/v3/developer-guide/images/async-vs-sync.png)


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

Plutôt que d'utiliser des promesses, vous devriez envisager d'utiliser async/await. Les fonctions asynchrones sont plus simples à utiliser que les promesses. Await ne peut être utilisé que dans une fonction asynchrone pour attendre une valeur de manière asynchrone.

L'exemple suivant permet async/await de répertorier toutes vos tables Amazon DynamoDB dans. ` us-west-2`

**Note**  
Pour exécuter cet exemple :  
Installez le client AWS SDK pour JavaScript DynamoDB en `npm install @aws-sdk/client-dynamodb` entrant dans la ligne de commande de votre projet.
Assurez-vous d'avoir correctement configuré vos AWS informations d'identification. Pour de plus amples informations, veuillez consulter [Définir les informations d'identification](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)
  }
})();
```

**Note**  
 Tous les navigateurs ne prennent pas en charge le mode async/await. Consultez la section [Fonctions asynchrones](https://caniuse.com/#feat=async-functions) pour obtenir la liste des navigateurs async/await compatibles. 

# JavaScript Promesses d'utilisation
<a name="using-promises"></a>

Utilisez la méthode AWS SDK pour JavaScript v3 (`ListTablesCommand`) du client de service pour effectuer l'appel de service et gérer le flux asynchrone au lieu d'utiliser des rappels. L'exemple suivant montre comment obtenir les noms de vos tables 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);
  });
```

## Coordonner plusieurs promesses
<a name="multiple-promises"></a>

Dans certains cas, votre code doit effectuer plusieurs appels asynchrones qui nécessitent une action uniquement lorsqu'ils sont tous renvoyés avec succès. Si vous gérez ces appels de méthode asynchrone individuels avec des promesses, vous pouvez créer une autre promesse qui utilise la méthode `all`. 

Cette méthode exécute cette promesse générique si et quand la série de promesses que vous transmettez dans la méthode est exécutée. La fonction de rappel reçoit une série des valeurs des promesses transmises à la méthode `all`.

Dans l'exemple suivant, une AWS Lambda fonction doit effectuer trois appels asynchrones à Amazon DynamoDB, mais elle ne peut se terminer que lorsque les promesses pour chaque appel ont été remplies.

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

## Support du navigateur et de Node.js pour les promesses
<a name="browser-node-promise-support"></a>

Support pour les JavaScript promesses natives (ECMAScript 2015) dépend du JavaScript moteur et de la version dans lesquels votre code s'exécute. Pour déterminer la prise en charge des JavaScript promesses dans chaque environnement dans lequel votre code doit être exécuté, consultez le [tableau de ECMAScript compatibilité](https://compat-table.github.io/compat-table/es6/) sur GitHub.

# Utiliser une fonction de rappel anonyme
<a name="using-a-callback-function"></a>

Chaque méthode d'objet de service peut accepter une fonction de rappel anonyme comme dernier paramètre. La signature de cette fonction de rappel est la suivante.

```
function(error, data) {
    // callback handling code
};
```

Cette fonction de rappel est exécutée lorsqu'une réponse positive ou des données d'erreur sont renvoyées. Si l'appel de méthode aboutit, le contenu de la réponse est disponible pour la fonction de rappel dans le paramètre `data`. Si l'appel n'aboutit pas, les détails relatifs à l'échec sont disponibles dans le paramètre `error`.

En général, le code à l'intérieur de la fonction de rappel effectue un test afin d'identifier une éventuelle erreur. Si une erreur est renvoyée, elle est traitée par le code. Si aucune erreur n'est renvoyée, le code récupère les données dans la réponse du paramètre `data`. La forme de base de la fonction de rappel ressemble à cet exemple.

```
function(error, data) {
    if (error) {
        // error handling code
        console.log(error);
    } else {
        // data handling code
        console.log(data);
    }
};
```

Dans l'exemple précédent, les détails de l'erreur ou ceux des données renvoyées sont consignés dans la console. Voici un exemple illustrant une fonction de rappel transmise dans le cadre de l'appel d'une méthode sur un objet de service.

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