O [Guia de referência da API do AWS SDK para JavaScript V3](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) descreve em detalhes todas as operações da API para o AWS SDK para JavaScript versão 3 (V3).
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Chamar serviços assincronamente
Todas as solicitações feitas por meio do SDK são assíncronas. É importante ter isso em mente ao escrever scripts de navegador. JavaScript a execução em um navegador da Web normalmente tem apenas um único thread de execução. Depois de fazer uma chamada assíncrona para um AWS serviço, o script do navegador continua em execução e, no processo, pode tentar executar o código que depende desse resultado assíncrono antes que ele retorne.
Fazer chamadas assíncronas para um AWS serviço inclui gerenciar essas chamadas para que seu código não tente usar dados antes que eles estejam disponíveis. Os tópicos desta seção explicam a necessidade de gerenciar chamadas assíncronas e detalha diferentes técnicas que você pode usar para gerenciá-las.
Embora você possa usar qualquer uma dessas técnicas para gerenciar chamadas assíncronas, recomendamos que você use async/await para todos os novos códigos.
async/await
Recomendamos que você use essa técnica, pois é o comportamento padrão na V3.
promise
Use essa técnica em navegadores que não são compatíveis com async/await.
callback
Evite usar callbacks, exceto em casos muito simples. No entanto, você pode achar que é útil para cenários de migração.
**Topics**
+ [Gerenciar chamadas assíncronas](making-asynchronous-calls.md)
+ [Usar async/await](using-async-await.md)
+ [Use JavaScript promessas](using-promises.md)
+ [Usar uma função de retorno de chamada anônima](using-a-callback-function.md)
# Gerenciar chamadas assíncronas
Por exemplo, a página inicial de um site de comércio eletrônico permite que os clientes que retornam façam login. Parte do benefício para os clientes que fazem login é que, depois de fazerem-no, o site se personaliza de acordo com suas preferências específicas. Para fazer isso acontecer:
1. O cliente deve fazer login e ser validado com suas credenciais de login.
1. As preferências do cliente são solicitadas a banco de dados de clientes.
1. O banco de dados fornece as preferências do cliente, que são usadas para personalizar o site antes que a página carregue.
Se essas tarefas forem executadas de forma síncrona, cada uma delas deverá terminar antes de a seguinte começar. A página da Web não terminaria de carregar até que as preferências do cliente fossem apresentadas pelo banco de dados. No entanto, após a consulta de banco de dados ser enviada ao servidor, o recebimento dos dados do cliente pode ser atrasado ou até mesmo falhar devido a gargalos da rede, tráfego excepcionalmente alto no banco de dados ou conexão ruim nos dispositivos móveis.
Para evitar que o site congele sob essas condições, chame o banco de dados de forma assíncrona. Depois de a chamada do banco de dados ser executada, enviando sua solicitação assíncrona, o código continuará a ser executado conforme o esperado. Se você não gerir adequadamente a resposta de uma chamada assíncrona, o código poderá tentar usar informações que espera de volta do banco de dados quando esses dados ainda não estiverem disponíveis.
![\[Mostrando a diferença entre a execução síncrona e a execução assíncrona.\]](http://docs.aws.amazon.com/pt_br/sdk-for-javascript/v3/developer-guide/images/async-vs-sync.png)
# Usar async/await
Em vez de usar promessas, considere o uso de async/await. As funções assíncronas são mais simples e usam menos boilerplate do que as promessas. Await só pode ser usado em uma função assíncrona para esperar assincronamente um valor.
O exemplo a seguir é usado async/await para listar todas as suas tabelas do Amazon DynamoDB em. ` us-west-2`
**nota**
Para executar este exemplo:
Instale o AWS SDK para JavaScript cliente do DynamoDB `npm install @aws-sdk/client-dynamodb` entrando na linha de comando do seu projeto.
Verifique se você configurou suas AWS credenciais corretamente. Para obter mais informações, consulte [Definir credenciais](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**
Nem todos os navegadores oferecem suporte para async/await. Consulte [Funções assíncronas](https://caniuse.com/#feat=async-functions) para obter uma lista de navegadores com async/await suporte.
# Use JavaScript promessas
Use o método AWS SDK para JavaScript v3 (`ListTablesCommand`) do cliente de serviço para fazer a chamada de serviço e gerenciar o fluxo assíncrono em vez de usar retornos de chamada. O exemplo a seguir mostra como obter os nomes de tabelas do Amazon DynamoDB em `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);
});
```
## Coordenar várias promessas
Em algumas situações, seu código deve fazer várias chamadas assíncronas que exigem ação somente quando todos tiverem sido retornados com êxito. Se você gerenciar as chamadas individuais do método assíncrono com promessas, pode criar uma promessa adicional que usa o método `all`.
Esse método cumpre essa promessa generalista se, e quando, a série de promessas que você passar para o método forem cumpridas. A função de retorno de chamada é transmitida a um array dos valores das promessas passadas para o método `all`.
No exemplo a seguir, uma AWS Lambda função deve fazer três chamadas assíncronas para o Amazon DynamoDB, mas só pode ser concluída depois que as promessas de cada chamada forem cumpridas.
```
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;
```
## Suporte de navegador e Node.js para promessas
Support for JavaScript native promise (ECMAScript 2015) depende do JavaScript mecanismo e da versão em que seu código é executado. Para ajudar a determinar o suporte para JavaScript promessas em cada ambiente em que seu código precisa ser executado, consulte a [tabela de ECMAScript compatibilidade](https://compat-table.github.io/compat-table/es6/) em GitHub.
# Usar uma função de retorno de chamada anônima
Cada método de objeto de serviço pode aceitar uma função de retorno de chamada anônima como o último parâmetro. A assinatura dessa função de retorno de chamada é:
```
function(error, data) {
// callback handling code
};
```
Essa função de retorno de chamada é executada ao se retornar uma resposta bem-sucedida ou dados de erro. Se a chamada do método for bem-sucedida, o conteúdo da resposta estará disponível para a função de retorno de chamada no parâmetro `data`. Se a chamada não for bem-sucedida, os detalhes sobre a falha são fornecidos no parâmetro `error`.
Normalmente o código dentro da função de retorno de chamada testa um erro, que ele processa, caso seja retornado um erro. Se o erro não for retornado, o código recuperará os dados na resposta pelo parâmetro `data`. O formato básico da função de retorno de chamada é semelhante a este exemplo.
```
function(error, data) {
if (error) {
// error handling code
console.log(error);
} else {
// data handling code
console.log(data);
}
};
```
No exemplo anterior, os detalhes do erro ou dos dados retornados são registrados no console. Veja a seguir um exemplo que mostra uma função de retorno de chamada passada como parte da chamada de um método em um objeto de serviço.
```
ec2.describeInstances(function(error, data) {
if (error) {
console.log(error); // an error occurred
} else {
console.log(data); // request succeeded
}
});
```