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.
# Verwenden eines Anforderungsobjektereignis-Listeners
Wenn Sie keine anonyme Callback-Funktion erstellen und als Parameter übergeben, wenn Sie eine Service-Objektmethode aufrufen, generiert der Methodenaufruf ein `AWS.Request`-Objekt, das mit dessen `send`-Methode manuell gesendet werden muss.
Zum Verarbeiten der Antwort müssen Sie einen Ereignis-Listener für das `AWS.Request`-Objekt erstellen, um eine Callback-Funktion für den Methodenaufruf zu registrieren. Das folgende Beispiel zeigt, wie das `AWS.Request`-Objekt zum Aufrufen einer Service-Objektmethode und der Ereignis-Listener für die erfolgreiche Rückgabe erstellt werden.
```
// create the AWS.Request object
var request = new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances();
// register a callback event handler
request.on('success', function(response) {
// log the successful data response
console.log(response.data);
});
// send the request
request.send();
```
Nachdem die `send`-Methode im `AWS.Request`-Objekt aufgerufen wurde, wird der Ereignis-Handler ausgeführt, wenn das Service-Objekt ein `AWS.Response`-Objekt erhält.
Weitere Informationen zu dem `AWS.Request` Objekt finden Sie [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)in der API-Referenz. Weitere Informationen über das `AWS.Response` Objekt finden Sie unter [Verwenden des Response-Objekts](the-response-object.md) oder [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html)in der API-Referenz.
## Verketten von mehreren Callbacks
Sie können mehrere Callbacks für jedes Anforderungsobjekt registrieren. Mehrere Callbacks können für verschiedene Ereignisse oder dasselbe Ereignis registriert werden. Sie können Callbacks auch verketten, wie im folgenden Beispiel gezeigt wird.
```
request.
on('success', function(response) {
console.log("Success!");
}).
on('error', function(response) {
console.log("Error!");
}).
on('complete', function() {
console.log("Always!");
}).
send();
```
## Anforderungsobjekt-Fertigstellungsereignis
Das `AWS.Request`-Objekt löst diese Fertigstellungsereignisse basierend auf der Antwort der einzelnen Service-Operationsmethoden aus:
+ `success`
+ `error`
+ `complete`
Sie können eine Callback-Funktion als Reaktion auf jedes dieser Ereignisse registrieren. Eine vollständige Liste aller Ereignisse mit Anforderungsobjekten finden Sie [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)in der API-Referenz.
### Das Erfolgsereignis
Das `success`-Ereignis wird ausgelöst, wenn eine erfolgreiche Antwort vom Service-Objekt erhalten wird. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('success', function(response) {
// event handler code
});
```
Die Antwort enthält eine `data`-Eigenschaft mit den serialisierten Antwortdaten vom Service. Zum Beispiel der folgende Aufruf der `listBuckets` Methode des Amazon S3-Serviceobjekts
```
s3.listBuckets.on('success', function(response) {
console.log(response.data);
}).send();
```
gibt die Antwort zurück. Anschließend wird der folgende Inhalt der `data`-Eigenschaft an die Konsole ausgegeben.
```
{ Owner: { ID: '...', DisplayName: '...' },
Buckets:
[ { Name: 'someBucketName', CreationDate: someCreationDate },
{ Name: 'otherBucketName', CreationDate: otherCreationDate } ],
RequestId: '...' }
```
### Das error-Ereignis
Das `error`-Ereignis wird ausgelöst, wenn eine Fehlerantwort vom Service-Objekt erhalten wird. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('error', function(error, response) {
// event handling code
});
```
Wenn das `error`-Ereignis ausgelöst wird, ist der Wert der `data`-Eigenschaft der Antwort `null` und die `error`-Eigenschaft enthält die Fehlerdaten. Das zugehörige `error`-Objekt wird als erster Parameter an die registrierte Callback-Funktion übergeben. Der folgende Code beispielsweise:
```
s3.config.credentials.accessKeyId = 'invalid';
s3.listBuckets().on('error', function(error, response) {
console.log(error);
}).send();
```
gibt den Fehler zurück. Anschließend werden die folgenden Fehlerdaten an die Konsole ausgegeben.
```
{ code: 'Forbidden', message: null }
```
### Das complete-Ereignis
Das `complete`-Ereignis wird ausgelöst, wenn ein Service-Objektaufruf unabhängig davon, ob der Aufruf erfolgreich war oder nicht, abgeschlossen wurde. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('complete', function(response) {
// event handler code
});
```
Verwenden Sie den `complete`-Ereignis-Callback, um die einzelnen Anforderungsbereinigungen zu verarbeiten, die unabhängig von Erfolg oder Fehlern ausgeführt werden müssen. Wenn Sie Antwortdaten in einer Callback-Funktion für das `complete`-Ereignis verwenden, überprüfen Sie zuerst die Eigenschaften `response.data` oder `response.error`, bevor Sie versuchen, auf eine der beiden zuzugreifen. Dies wird in folgendem Beispiel gezeigt.
```
request.on('complete', function(response) {
if (response.error) {
// an error occurred, handle it
} else {
// we can use response.data here
}
}).send();
```
## HTTP-Ereignisse für Anforderungsobjekte
Das `AWS.Request`-Objekt löst die folgenden HTTP-Ereignisse basierend auf der Antwort der einzelnen Service-Operationsmethoden aus:
+ `httpHeaders`
+ `httpData`
+ `httpUploadProgress`
+ `httpDownloadProgress`
+ `httpError`
+ `httpDone`
Sie können eine Callback-Funktion als Reaktion auf jedes dieser Ereignisse registrieren. Eine vollständige Liste aller Ereignisse mit Anforderungsobjekten finden Sie [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)in der API-Referenz.
### Das httpHeaders-Ereignis
Das `httpHeaders`-Ereignis wird ausgelöst, wenn Header vom Remote-Server gesendet werden. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('httpHeaders', function(statusCode, headers, response) {
// event handling code
});
```
Der `statusCode`-Parameter der Callback-Funktion ist der HTTP-Statuscode. Der `headers`-Parameter enthält die Antwort-Header.
### Das httpData-Ereignis
Das `httpData`-Ereignis wird ausgelöst, um Antwortdatenpakete vom Service zu streamen. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('httpData', function(chunk, response) {
// event handling code
});
```
Dieses Ereignis wird in der Regel für den Empfang großer Antwortblöcke verwendet, wenn das Laden der gesamten Antwort in den Arbeitsspeicher nicht praktikabel ist. Dieses Ereignis verfügt über einen zusätzlichen `chunk`-Parameter, der einen Teil der eigentlichen Daten vom Server enthält.
Wenn Sie einen Callback für das `httpData`-Ereignis registrieren, enthält die `data`-Eigenschaft der Antwort die gesamte serialisierte Ausgabe für die Anforderung. Sie müssen den standardmäßigen `httpData`-Listener entfernen, wenn Sie nicht über den zusätzlichen Analyse- und Speichermehraufwand für die integrierten Handler verfügen.
### Die httpUploadProgress und httpDownloadProgress Ereignisse
Das `httpUploadProgress`-Ereignis wird ausgelöst, wenn die HTTP-Anforderung mehr Daten hochgeladen hat. Entsprechend wird das `httpDownloadProgress`-Ereignis ausgelöst, wenn die HTTP-Anforderung mehr Daten heruntergeladen hat. Hier sehen Sie, wie Sie eine Callback-Funktion für diese Ereignisse registrieren.
```
request.on('httpUploadProgress', function(progress, response) {
// event handling code
})
.on('httpDownloadProgress', function(progress, response) {
// event handling code
});
```
Der `progress`-Parameter der Callback-Funktion enthält ein Objekt mit den geladenen und gesamten Bytes der Anforderung.
### Das httpError-Ereignis
Das `httpError`-Ereignis wird ausgelöst, wenn die HTTP-Anforderung fehlschlägt. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('httpError', function(error, response) {
// event handling code
});
```
Der `error`-Parameter der Callback-Funktion enthält die Fehler, die ausgelöst wurden.
### Das httpDone-Ereignis
Das `httpDone`-Ereignis wird ausgelöst, wenn der Server das Senden von Daten abgeschlossen hat. Hier sehen Sie, wie Sie eine Callback-Funktion für dieses Ereignis registrieren.
```
request.on('httpDone', function(response) {
// event handling code
});
```