Die AWS SDK für JavaScript Version 2 ist erreicht end-of-support. Wir empfehlen Ihnen, auf [AWS SDK für JavaScript Version 3](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/) zu migrieren. Weitere Einzelheiten und Informationen zur Migration finden Sie in dieser [Ankündigung](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/).

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.

# Promises verwenden JavaScript
<a name="using-promises"></a>

Mit der `AWS.Request.promise`-Methode haben Sie die Möglichkeit, eine Service-Operation aufzurufen und asynchrone Flows zu verwalten, anstatt Callbacks zu verwenden. In Node.js und Browser-Skripts wird ein `AWS.Request`-Objekt zurückgegeben, wenn eine Service-Operation ohne eine Callback-Funktion aufgerufen wird. Sie können die `send`-Methode der Anforderung aufrufen, um den Service aufzurufen.

`AWS.Request.promise` startet jedoch sofort den Service-Aufruf und gibt ein Promis zurück. Dieses wird entweder mit der `data`-Eigenschaft der Antwort erfüllt oder mit der `error`-Eigenschaft der Antwort abgelehnt.

```
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 */
  }
);
```

Das nächste Beispiel gibt ein Promis zurück, das mit einem `data`-Objekt erfüllt oder mit einem `error`-Objekt abgelehnt wird. Beim Verwenden von Promises ist ein einzelner Callback nicht dafür zuständig, Fehler zu erkennen. Stattdessen wird der richtige Callback basierend auf dem Erfolg oder Misserfolg einer Anforderung aufgerufen.

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

## Koordinieren mehrerer Promises
<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.

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

## Browser- und Node.js-Unterstützung für 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 [ECMAScriptKompatibilitätstabelle unter.](https://compat-table.github.io/compat-table/es6/) GitHub

## Verwenden anderer Promise-Implementierungen
<a name="using-other-promise-implementations"></a>

Zusätzlich zur systemeigenen Promise-Implementierung im ECMAScript Jahr 2015 können Sie auch Promise-Bibliotheken von Drittanbietern verwenden, darunter:
+ [Bluebird](http://bluebirdjs.com)
+ [RSVP](https://github.com/tildeio/rsvp.js/)
+ [Q](https://github.com/kriskowal/q)

Diese optionalen Promise-Bibliotheken können nützlich sein, wenn Sie Ihren Code in Umgebungen ausführen möchten, die die native Promise-Implementierung in ECMAScript 5 und ECMAScript 2015 nicht unterstützen.

Wenn Sie die Promise-Bibliothek eines Drittanbieters verwenden möchten, legen Sie eine Promise-Abhängigkeit im SDK fest, indem Sie die `setPromisesDependency`-Methode des globalen Konfigurationsobjekts aufrufen. Stellen Sie in Browser-Skripts sicher, dass die Promise-Drittanbieterbibliothek vor dem SDK geladen wird. Im folgenden Beispiel wird das SDK so konfiguriert, dass es die Implementierung in der Bluebird-Promise-Bibliothek verwendet.

```
AWS.config.setPromisesDependency(require('bluebird'));
```

Um wieder die native Promise-Implementierung der JavaScript Engine zu verwenden, rufen Sie `setPromisesDependency` erneut auf und übergeben Sie `null` statt eines Bibliotheksnamens einen.