La AWS SDK per JavaScript v2 è arrivata. end-of-support [Ti consigliamo di migrare alla AWS SDK per JavaScript v3.](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/) [Per ulteriori dettagli e informazioni su come effettuare la migrazione, consulta questo annuncio.](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/)

Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Utilizzo dell'oggetto di risposta
<a name="the-response-object"></a>

Una volta chiamato, un metodo dell'oggetto di servizio restituisce un oggetto `AWS.Response` trasferendolo alla tua funzione di callback. Accedi ai contenuti della risposta attraverso le proprietà dell'oggetto `AWS.Response`. Esistono due proprietà dell'oggetto `AWS.Response` che utilizzi per accedere ai contenuti della risposta:
+ Proprietà `data` 
+ Proprietà `error` 

Quando utilizzi il meccanismo di callback standard, queste due proprietà vengono fornite come parametri sulla funzione di callback anonimo, come illustrato nell'esempio seguente.

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

## Accesso ai dati restituiti nell'oggetto di risposta
<a name="response-data-property"></a>

La proprietà `data` dell'oggetto `AWS.Response` contiene i dati serializzati restituiti dalla richiesta di servizio. Quando la richiesta ha esito positivo, la proprietà `data` include un oggetto contenente una mappa per i dati restituiti. La proprietà `data` può essere null se si verifica un errore.

Ecco un esempio di chiamata al `getItem` metodo di una tabella DynamoDB per recuperare il nome di un file di immagine da utilizzare come parte di un gioco.

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

Per questo esempio, la tabella DynamoDB è una ricerca di immagini che mostrano i risultati del pull di una slot machine come specificato dai parametri in. `slotParams`

Dopo una chiamata riuscita del `getItem` metodo, la `data` proprietà dell'`AWS.Response`oggetto contiene un `Item` oggetto restituito da DynamoDB. Puoi accedere ai dati restituiti in base al parametro `ProjectionExpression` della richiesta, che in questo caso indica il membro `imageFile` dell'oggetto `Item`. Poiché il membro `imageFile` contiene un valore di stringa, puoi accedere al nome file dell'immagine stessa attraverso il valore del membro figlio `S` di `imageFile`.

## Paging tramite dati restituiti
<a name="response-paged-data"></a>

A volte il contenuto della proprietà `data` restituito da una richiesta di servizio si estende su più pagine. Puoi accedere alla successiva pagina di dati chiamando il metodo `response.nextPage`. Questo metodo invia una nuova richiesta. La risposta della richiesta può essere acquisita con un callback o con i listener di errore e di operazione riuscita.

Puoi verificare se i dati restituiti da una richiesta di servizio includono pagine di dati aggiuntive chiamando il metodo `response.hasNextPage`. Questo metodo restituisce un valore booleano per indicare se la chiamata `response.nextPage` restituisce dati aggiuntivi.

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

## Accesso alle informazioni sugli errori da un oggetto di risposta
<a name="response-error-property"></a>

La proprietà `error` dell'oggetto `AWS.Response` contiene i dati dell'errore disponibili in caso di errore di servizio o di trasferimento. L'errore restituito presenta il seguente formato.

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

Se si verifica un errore, il valore della proprietà `data` è `null`. Se gestisci eventi che possono essere in uno stato di errore, controlla sempre se la proprietà `error` è stata impostata prima di tentare di accedere al valore della proprietà `data`.

## Accesso all'oggetto di richiesta originario
<a name="response-request-property"></a>

La proprietà `request` fornisce l'accesso all'oggetto `AWS.Request` originario. Può essere utile fare riferimento all'oggetto `AWS.Request` originario per accedere ai parametri originali inviati. Nell'esempio seguente, la proprietà `request` viene utilizzata per accedere al parametro `Key` della richiesta di servizio originale.

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