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 di un listener di eventi oggetto di richiesta
Se non crei e trasferisci una funzione di callback anonimo come parametro quando chiami un metodo dell'oggetto di servizio, la chiamata al metodo genera un oggetto `AWS.Request` che deve essere inviato manualmente utilizzando il relativo metodo `send`.
Per elaborare la risposta, devi creare un listener di eventi per l'oggetto `AWS.Request` per registrare una funzione di callback per la chiamata al metodo. L'esempio seguente mostra come creare l'oggetto `AWS.Request` per chiamare un metodo dell'oggetto di servizio e il listener di eventi per l'esito positivo.
```
// 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();
```
Dopo aver chiamato il metodo `send` sul'oggetto `AWS.Request`, viene eseguito il gestore eventi quando l'oggetto di servizio riceve un oggetto `AWS.Response`.
Per ulteriori informazioni sull'`AWS.Request`oggetto, consulta [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)l'API Reference. Per ulteriori informazioni sull'`AWS.Response`oggetto, consulta [Utilizzo dell'oggetto di risposta](the-response-object.md) o [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html)consulta l'API Reference.
## Concatenazione di più callback
Puoi registrare più callback su qualsiasi oggetto di richiesta. È possibile registrare più callback per diversi eventi o per lo stesso evento. Puoi anche concatenare i callback come mostrato nell'esempio seguente.
```
request.
on('success', function(response) {
console.log("Success!");
}).
on('error', function(response) {
console.log("Error!");
}).
on('complete', function() {
console.log("Always!");
}).
send();
```
## Eventi di completamento degli oggetti di richiesta
L'oggetto `AWS.Request` genera questi eventi di completamento in base alla risposta di ciascun metodo dell'operazione di servizio:
+ `success`
+ `error`
+ `complete`
Puoi registrarsi una funzione di callback in risposta a uno qualsiasi di questi eventi. Per un elenco completo di tutti gli eventi relativi all'oggetto della richiesta, [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)consulta l'API Reference.
### Evento success
L'evento `success` viene generato in seguito a una risposta positiva ricevuta dall'oggetto di servizio. Ecco come si registra una funzione di callback per questo evento.
```
request.on('success', function(response) {
// event handler code
});
```
La risposta fornisce una proprietà `data` che contiene i dati di risposta serializzati dal servizio. Ad esempio, la seguente chiamata al `listBuckets` metodo dell'oggetto di servizio Amazon S3
```
s3.listBuckets.on('success', function(response) {
console.log(response.data);
}).send();
```
restituisce la risposta e quindi stampa i seguenti contenuti della proprietà `data` nella console.
```
{ Owner: { ID: '...', DisplayName: '...' },
Buckets:
[ { Name: 'someBucketName', CreationDate: someCreationDate },
{ Name: 'otherBucketName', CreationDate: otherCreationDate } ],
RequestId: '...' }
```
### Evento error
L'evento `error` viene generato in seguito a una risposta di errore ricevuta dall'oggetto di servizio. Ecco come si registra una funzione di callback per questo evento.
```
request.on('error', function(error, response) {
// event handling code
});
```
Quando viene generato l'evento `error`, il valore della proprietà `data` della risposta è `null` e la proprietà `error` contiene i dati dell'errore. L'oggetto `error` associato viene trasferito come primo parametro alla funzione di callback registrata. Ad esempio, il seguente codice:
```
s3.config.credentials.accessKeyId = 'invalid';
s3.listBuckets().on('error', function(error, response) {
console.log(error);
}).send();
```
restituisce l'errore e quindi stampa i seguenti dati dell'errore nella console.
```
{ code: 'Forbidden', message: null }
```
### Evento complete
L'evento `complete` viene generato al termine della chiamata a un oggetto di servizio, indipendentemente dal fatto che la chiamata abbia esito positivo o negativo. Ecco come si registra una funzione di callback per questo evento.
```
request.on('complete', function(response) {
// event handler code
});
```
Utilizza il callback dell'evento `complete` per gestire qualsiasi pulizia delle richieste che deve essere eseguita indipendentemente dall'esito positivo o negativo. Se utilizzi i dati di risposta all'interno di un callback per l'evento `complete`, verifica le proprietà `response.data` o `response.error` prima di tentare di accedervi, come mostrato nell'esempio seguente.
```
request.on('complete', function(response) {
if (response.error) {
// an error occurred, handle it
} else {
// we can use response.data here
}
}).send();
```
## Eventi HTTP degli oggetti di richiesta
L'oggetto `AWS.Request` genera questi eventi HTTP in base alla risposta di ciascun metodo dell'operazione di servizio:
+ `httpHeaders`
+ `httpData`
+ `httpUploadProgress`
+ `httpDownloadProgress`
+ `httpError`
+ `httpDone`
Puoi registrarsi una funzione di callback in risposta a uno qualsiasi di questi eventi. Per un elenco completo di tutti gli eventi relativi all'oggetto della richiesta, consulta [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)l'API Reference.
### Evento httpHeaders
L'evento `httpHeaders` viene generato quando vengono inviate le intestazioni dal server remoto. Ecco come si registra una funzione di callback per questo evento.
```
request.on('httpHeaders', function(statusCode, headers, response) {
// event handling code
});
```
Il parametro `statusCode` della funzione di callback è il codice di stato HTTP. Il parametro `headers` contiene le intestazioni di risposta.
### Evento httpData
L'evento `httpData` viene generato per eseguire lo streaming dei pacchetti di dati di risposta dal servizio. Ecco come si registra una funzione di callback per questo evento.
```
request.on('httpData', function(chunk, response) {
// event handling code
});
```
Questo evento viene in genere utilizzato per ricevere risposte di grandi dimensioni in blocchi quando il caricamento dell'intera risposta in memoria non è una soluzione pratica. Questo evento ha un parametro `chunk` aggiuntivo che contiene una parte dei dati effettivi dal server.
Se registri un callback per l'evento `httpData`, la proprietà `data` della risposta contiene l'intero output serializzato per la richiesta. Devi rimuovere il listener `httpData` predefinito se non disponi dell'overhead di analisi e memoria extra per i gestori incorporati.
### Gli httpUploadProgress ed httpDownloadProgress eventi
L'evento `httpUploadProgress` viene generato quando la richiesta HTTP ha caricato più dati. Allo stesso modo, l'evento `httpDownloadProgress` viene generato quando la richiesta HTTP ha scaricato più dati. Ecco come si registra una funzione di callback per questi eventi.
```
request.on('httpUploadProgress', function(progress, response) {
// event handling code
})
.on('httpDownloadProgress', function(progress, response) {
// event handling code
});
```
Il parametro `progress` della funzione di callback contiene un oggetto con i byte caricati e totali della richiesta.
### Evento httpError
L'evento `httpError` viene generato quando la richiesta HTTP ha esito negativo. Ecco come si registra una funzione di callback per questo evento.
```
request.on('httpError', function(error, response) {
// event handling code
});
```
Il parametro `error` della funzione di callback contiene l'errore che è stato generato.
### Evento httpDone
L'evento `httpDone` viene generato quando il server termina l'invio di dati. Ecco come si registra una funzione di callback per questo evento.
```
request.on('httpDone', function(response) {
// event handling code
});
```