Das [AWS SDK für JavaScript V3-API-Referenzhandbuch](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/) beschreibt detailliert alle API-Operationen für die AWS SDK für JavaScript Version 3 (V3). 

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Rufen Sie Dienste asynchron auf
<a name="calling-services-asynchronously"></a>

Alle über das SDK ausgeführten Anforderungen sind asynchron. Dies ist wichtig, wenn Sie Browserskripts schreiben. JavaScript Die Ausführung in einem Webbrowser hat normalerweise nur einen einzigen Ausführungsthread. Nach einem asynchronen Aufruf eines AWS Dienstes wird das Browserskript weiter ausgeführt und kann dabei versuchen, Code auszuführen, der von diesem asynchronen Ergebnis abhängt, bevor er zurückkehrt.

Zu asynchronen Aufrufen eines AWS Dienstes gehört auch die Verwaltung dieser Aufrufe, sodass Ihr Code nicht versucht, Daten zu verwenden, bevor die Daten verfügbar sind. Die Themen in diesem Abschnitt erklären, wie wichtig es ist, asynchrone Aufrufe zu verwalten, und erläutern die verschiedenen Verwaltungstechniken im Detail.

Sie können zwar jede dieser Techniken verwenden, um asynchrone Aufrufe zu verwalten, wir empfehlen jedoch, sie async/await für jeden neuen Code zu verwenden.

async/await  
Wir empfehlen Ihnen, diese Technik zu verwenden, da sie das Standardverhalten in Version 3 ist.

versprechen  
Verwenden Sie diese Technik in Browsern, die Async/Await nicht unterstützen.

Rückruf  
Vermeiden Sie Rückrufe, außer in sehr einfachen Fällen. Sie könnten es jedoch für Migrationsszenarien nützlich finden.

**Topics**
+ [Asynchrone Aufrufe verwalten](making-asynchronous-calls.md)
+ [Verwenden Sie async/await](using-async-await.md)
+ [Verwenden Sie Versprechen JavaScript](using-promises.md)
+ [Verwenden Sie eine anonyme Rückruffunktion](using-a-callback-function.md)

# Asynchrone Aufrufe verwalten
<a name="making-asynchronous-calls"></a>

Beispiel: Die Startseite einer E-Commerce-Website bietet wiederkehrenden Kunden die Möglichkeit, sich anzumelden. Die Kunden, die sich anmelden, profitieren u. a. davon, dass sich die Website nach der Anmeldung an ihre besonderen Präferenzen anpasst. Dafür ist Folgendes erforderlich:

1. Der Kunde muss sich anmelden und mit seinen Anmeldedaten validiert werden.

1. Die Präferenzen des Kunden werden von einer Kundendatenbank angefordert.

1. Die Datenbank stellt die Präferenzen des Kunden bereit, mit denen die Website angepasst wird, bevor die Seite geladen wird.

Wenn diese Aufgaben synchron ausgeführt werden, muss jede abgeschlossen sein, bevor die nächste starten kann. Das Laden der Webseite kann erst abgeschlossen werden, wenn die Kundeneinstellungen aus der Datenbank zurückgegeben werden. Nachdem die Datenbankabfrage an den Server gesendet wurde, kann der Empfang der Kundendaten jedoch aufgrund von Netzwerkengpässen, besonders hohem Datenverkehr oder einer schlechten Verbindung eines Mobilgeräts sich verzögern oder sogar fehlschlagen.

Um zu verhindern, dass die Website unter diesen Bedingungen einfriert, rufen Sie die Datenbank asynchron auf. Nachdem der Datenbankaufruf ausgeführt und Ihre asynchrone Anforderung gesendet wurde, wird Ihr Code wie erwartet weiter ausgeführt. Wenn Sie die Antwort eines asynchronen Aufrufs nicht ordnungsgemäß verwalten, versucht Ihr Code möglicherweise im Fall, dass diese Daten noch nicht verfügbar sind, Informationen zu verwenden, die er von der Datenbank zurückerwartet.

![\[Darstellung des Unterschieds zwischen synchroner und asynchroner Ausführung\]](http://docs.aws.amazon.com/de_de/sdk-for-javascript/v3/developer-guide/images/async-vs-sync.png)


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

Anstatt Versprechen zu verwenden, sollten Sie async/awawait verwenden. Async-Funktionen sind einfacher und benötigen weniger Boilerplate als die Verwendung von Versprechen. Await kann nur in einer asynchronen Funktion verwendet werden, um asynchron auf einen Wert zu warten.

Das folgende Beispiel verwendet async/await , um all Ihre Amazon DynamoDB-Tabellen in aufzulisten. ` us-west-2`

**Anmerkung**  
Damit dieses Beispiel ausgeführt werden kann:  
Installieren Sie den AWS SDK für JavaScript DynamoDB-Client, indem Sie ihn `npm install @aws-sdk/client-dynamodb` in die Befehlszeile Ihres Projekts eingeben.
Stellen Sie sicher, dass Sie Ihre AWS Anmeldeinformationen korrekt konfiguriert haben. Weitere Informationen finden Sie unter [Legen Sie die Anmeldeinformationen fest](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)
  }
})();
```

**Anmerkung**  
 Nicht alle Browser unterstützen Async/Await. Eine Liste der Browser, die Unterstützung bieten, finden Sie unter [Async-Funktionen](https://caniuse.com/#feat=async-functions). async/await 

# Verwenden Sie Versprechen JavaScript
<a name="using-promises"></a>

Verwenden Sie die AWS SDK für JavaScript v3-Methode (`ListTablesCommand`) des Service-Clients, um den Service aufzurufen und den asynchronen Ablauf zu verwalten, anstatt Callbacks zu verwenden. Das folgende Beispiel zeigt, wie Sie die Namen Ihrer Amazon DynamoDB-Tabellen abrufen können. `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);
  });
```

## Koordinieren Sie mehrere Versprechen
<a name="multiple-promises"></a>

In einigen Fällen muss Ihr Code mehrere asynchrone Aufrufe ausführen, die nur dann eine Aktion erfordern, wenn alle erfolgreich zurückgegeben wurden. Wenn Sie diese einzelnen asynchronen Methodenaufrufe mit Promises verwalten, können Sie ein zusätzliches Promise erstellen, das die `all`-Methode verwendet. 

Diese Methode erfüllt dieses übergeordnete Promise-Objekt, falls und wenn das an die Methode übergebene Array der Promises erfüllt ist. Die Callback-Funktion wird als Array von Werten der Promises übergeben, die an die `all`-Methode übergeben werden.

Im folgenden Beispiel muss eine AWS Lambda Funktion drei asynchrone Aufrufe an Amazon DynamoDB tätigen, kann aber erst abgeschlossen werden, nachdem die Zusagen für jeden Aufruf erfüllt wurden.

```
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- und Node.js unterstützen Promises
<a name="browser-node-promise-support"></a>

Die Support für native JavaScript Promises (ECMAScript 2015) hängt von der JavaScript Engine und Version ab, in der Ihr Code ausgeführt wird. Informationen zur Unterstützung von JavaScript Promises in den einzelnen Umgebungen, in denen Ihr Code ausgeführt werden muss, finden Sie in der [ECMAScript Kompatibilitätstabelle](https://compat-table.github.io/compat-table/es6/) unter GitHub.

# Verwenden Sie eine anonyme Rückruffunktion
<a name="using-a-callback-function"></a>

Jede Serviceobjektmethode kann eine anonyme Callback-Funktion als letzten Parameter akzeptieren. Die Signatur dieser Callback-Funktion lautet wie folgt.

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

Diese Callback-Funktion wird ausgeführt, wenn entweder eine erfolgreiche Antwort oder Fehlerdaten zurückgegeben werden. Wenn der Methodenaufruf erfolgreich war, wird der Callback-Funktion der Inhalt der Antwort im `data`-Parameter bereitgestellt. Wenn der Aufruf nicht erfolgreich war, werden die Details über den Fehler im `error`-Parameter angegeben.

In der Regel prüft der Code innerhalb der Callback-Funktion, ob ein Fehler vorliegt, den er verarbeitet, wenn ein Fehler zurückgegeben wird. Wenn kein Fehler zurückgegeben wird, ruft der Code die Antwortdaten vom `data`-Parameter ab. Die grundlegende Form der Callback-Funktion sieht wie folgt aus.

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

Im vorherigen Beispiel werden die Details zum Fehler oder die zurückgegebenen Daten in der Konsole protokolliert. Hier finden Sie ein Beispiel für eine Callback-Funktion, die als Teil des Aufrufs einer Methode in einem Service-Objekt zurückgegeben wird.

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