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 des Response-Objekts
<a name="the-response-object"></a>

Nachdem eine Service-Objektmethode aufgerufen wurde, gibt diese ein `AWS.Response`-Objekt zurück, indem es an Ihre Callback-Funktion übergeben wird. Sie greifen auf den Inhalt der Antwort über die Eigenschaften des `AWS.Response`-Objekts zu. Für den Zugriff auf den Inhalt der Antwort gibt es zwei Eigenschaften des `AWS.Response`-Objekts:
+ `data` Eigenschaft
+ `error` Eigenschaft

Wenn Sie den standardmäßigen Callback-Mechanismus verwenden, werden diese beiden Eigenschaften als Parameter in der anonymen Callback-Funktion bereitgestellt, wie das folgende Beispiel zeigt.

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

## Zugreifen auf im Response-Objekt zurückgegebene Daten
<a name="response-data-property"></a>

Die `data`-Eigenschaft des `AWS.Response`-Objekts enthält die serialisierten Daten, die von der Service-Anforderung zurückgegeben werden. Wenn die Anforderung erfolgreich ist, enthält die `data`-Eigenschaft ein Objekt mit einer Zuordnung zu den zurückgegebenen Daten. Die `data`-Eigenschaft kann Null sein, wenn ein Fehler auftritt.

Hier ist ein Beispiel für den Aufruf der `getItem` Methode einer DynamoDB-Tabelle, um den Dateinamen einer Bilddatei abzurufen, die als Teil eines Spiels verwendet werden soll.

```
// Initialize parameters needed to call DynamoDB
var slotParams = {
    Key : {'slotPosition' : {N: '0'}},
    TableName : 'slotWheels',
    ProjectionExpression: 'imageFile'
};

// prepare request object for call to DynamoDB
var request = new AWS.DynamoDB({region: 'us-west-2', apiVersion: '2012-08-10'}).getItem(slotParams);
// log the name of the image file to load in the slot machine
request.on('success', function(response) {
    // logs a value like "cherries.jpg" returned from DynamoDB
    console.log(response.data.Item.imageFile.S);
});
// submit DynamoDB request
request.send();
```

In diesem Beispiel ist die DynamoDB-Tabelle eine Suche nach Bildern, die die Ergebnisse eines Spielautomaten-Pulls zeigen, wie durch die Parameter in angegeben. `slotParams`

Bei einem erfolgreichen Aufruf der `getItem` Methode enthält die `data` Eigenschaft des `AWS.Response` Objekts ein von DynamoDB zurückgegebenes `Item` Objekt. Auf die zurückgegebenen Daten wird gemäß dem `ProjectionExpression`-Parameter der Anforderung zugegriffen, in diesem Fall also dem `imageFile`-Mitglied des `Item`-Objekts. Da das `imageFile`-Mitglied einen Zeichenfolgenwert enthält, können Sie auf den Dateinamen des Bildes über den Wert des untergeordneten Mitglieds `S` von `imageFile` zugreifen.

## Durchblättern von zurückgegebenen Daten
<a name="response-paged-data"></a>

Manchmal umfasst der Inhalt der von einer Service-Anforderung zurückgegebenen `data`-Eigenschaft mehrere Seiten. Sie können auf die nächste Datenseite mit dem Aufruf der `response.nextPage`-Methode zugreifen. Diese Methode sendet eine neue Anforderung. Die Antwort auf die Anforderung kann entweder mit einem Callback oder einem Listener für Erfolg oder Fehler erfasst werden.

Sie können prüfen, ob die von einer Service-Anforderung zurückgegebenen Daten zusätzliche Datenseiten haben, indem Sie die `response.hasNextPage`-Methode aufrufen. Diese Methode gibt einen booleschen Wert zurück, der angibt, ob der Aufruf von `response.nextPage` zusätzliche Daten zurückgibt.

```
s3.listObjects({Bucket: 'bucket'}).on('success', function handlePage(response) {
    // do something with response.data
    if (response.hasNextPage()) {
        response.nextPage().on('success', handlePage).send();
    }
}).send();
```

## Zugreifen auf Fehlerinformationen aus einem Antwortobjekt
<a name="response-error-property"></a>

Die `error`-Eigenschaft des `AWS.Response`-Objekts enthält die verfügbaren Fehlerdaten bei einem Service-Fehler oder einem Übertragungsfehler. Der zurückgegebene Fehler hat das folgende Format.

```
{ code: 'SHORT_UNIQUE_ERROR_CODE', message: 'a descriptive error message' }
```

Im Fall eines Fehlers ist der Wert der `data`-Eigenschaft gleich `null`. Wenn Sie Ereignisse verarbeiten, die sich in einem Fehlerzustand befinden können, überprüfen Sie immer, ob die `error`-Eigenschaft festgelegt wurde, bevor Sie versuchen, auf den Wert der `data`-Eigenschaft zuzugreifen.

## Zugreifen auf das ursprüngliche Anforderungsobjekt
<a name="response-request-property"></a>

Die `request`-Eigenschaft bietet Zugriff auf das ursprüngliche `AWS.Request`-Objekt. Es kann nützlich sein, Bezug auf das ursprüngliche `AWS.Request`-Objekt zu nehmen, um auf die ursprünglichen Parameter zuzugreifen, die es gesendet hat. Im folgenden Beispiel wird die `request`-Eigenschaft verwendet, um auf den `Key`-Parameter der ursprünglichen Service-Anforderung zuzugreifen.

```
s3.getObject({Bucket: 'bucket', Key: 'key'}).on('success', function(response) {
   console.log("Key was", response.request.params.Key);
}).send();
```