AWS SDK untuk JavaScript V2 telah mencapai end-of-support. Kami menyarankan Anda bermigrasi ke [AWS SDK untuk JavaScript v3](https://docs.aws.amazon.com//sdk-for-javascript/v3/developer-guide/). Untuk detail dan informasi tambahan tentang cara bermigrasi, silakan lihat [pengumuman](https://aws.amazon.com/blogs//developer/announcing-end-of-support-for-aws-sdk-for-javascript-v2/) ini.
Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Layanan Panggilan Secara Asinkron
Semua permintaan yang dibuat melalui SDK bersifat asinkron. Ini penting untuk diingat saat menulis skrip browser. JavaScript berjalan di browser web biasanya hanya memiliki satu thread eksekusi. Setelah melakukan panggilan asinkron ke AWS layanan, skrip browser terus berjalan dan dalam proses dapat mencoba mengeksekusi kode yang bergantung pada hasil asinkron sebelum kembali.
Membuat panggilan asinkron ke AWS layanan termasuk mengelola panggilan tersebut sehingga kode Anda tidak mencoba menggunakan data sebelum data tersedia. Topik di bagian ini menjelaskan perlunya mengelola panggilan asinkron dan merinci berbagai teknik yang dapat Anda gunakan untuk mengelolanya.
**Topics**
+ [Mengelola Panggilan Asinkron](making-asynchronous-calls.md)
+ [Menggunakan Fungsi Callback Anonim](using-a-callback-function.md)
+ [Menggunakan Request Object Event Listener](using-a-response-event-handler.md)
+ [Menggunakan async/await](using-async-await.md)
+ [Menggunakan JavaScript Janji](using-promises.md)
# Mengelola Panggilan Asinkron
Misalnya, halaman beranda situs web e-commerce memungkinkan pelanggan yang kembali masuk. Bagian dari manfaat bagi pelanggan yang masuk adalah bahwa, setelah masuk, situs kemudian menyesuaikan diri dengan preferensi khusus mereka. Untuk membuat ini terjadi:
1. Pelanggan harus masuk dan divalidasi dengan kredensi masuk mereka.
1. Preferensi pelanggan diminta dari database pelanggan.
1. Basis data menyediakan preferensi pelanggan yang digunakan untuk menyesuaikan situs sebelum halaman dimuat.
Jika tugas-tugas ini dijalankan secara serempak, maka masing-masing harus selesai sebelum tugas berikutnya dapat dimulai. Halaman web tidak akan dapat menyelesaikan pemuatan sampai preferensi pelanggan kembali dari database. Namun, setelah kueri database dikirim ke server, penerimaan data pelanggan dapat ditunda atau bahkan gagal karena kemacetan jaringan, lalu lintas basis data yang sangat tinggi, atau koneksi perangkat seluler yang buruk.
Agar situs web tidak membeku dalam kondisi tersebut, hubungi database secara tidak sinkron. Setelah panggilan database dijalankan, mengirimkan permintaan asinkron Anda, kode Anda terus dijalankan seperti yang diharapkan. Jika Anda tidak mengelola respons panggilan asinkron dengan benar, kode Anda dapat mencoba menggunakan informasi yang diharapkan kembali dari database ketika data tersebut belum tersedia.
![\[Menampilkan perbedaan antara eksekusi sinkron dan asinkron.\]](http://docs.aws.amazon.com/id_id/sdk-for-javascript/v2/developer-guide/images/async-vs-sync.png)
# Menggunakan Fungsi Callback Anonim
Setiap metode objek layanan yang membuat `AWS.Request` objek dapat menerima fungsi callback anonim sebagai parameter terakhir. Tanda tangan dari fungsi callback ini adalah:
```
function(error, data) {
// callback handling code
}
```
Fungsi callback ini dijalankan ketika respon berhasil atau data kesalahan kembali. Jika pemanggilan metode berhasil, isi respons tersedia untuk fungsi callback dalam parameter. `data` Jika panggilan tidak berhasil, detail tentang kegagalan disediakan dalam `error` parameter.
Biasanya kode di dalam fungsi callback menguji kesalahan, yang diproses jika dikembalikan. Jika kesalahan tidak dikembalikan, kode kemudian mengambil data dalam respons dari `data` parameter. Bentuk dasar dari fungsi callback terlihat seperti contoh ini.
```
function(error, data) {
if (error) {
// error handling code
console.log(error);
} else {
// data handling code
console.log(data);
}
}
```
Pada contoh sebelumnya, detail kesalahan atau data yang dikembalikan dicatat ke konsol. Berikut adalah contoh yang menunjukkan fungsi callback diteruskan sebagai bagian dari memanggil metode pada objek layanan.
```
new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(function(error, data) {
if (error) {
console.log(error); // an error occurred
} else {
console.log(data); // request succeeded
}
});
```
## Mengakses Objek Permintaan dan Respons
Dalam fungsi callback, JavaScript kata kunci `this` mengacu pada `AWS.Response` objek yang mendasari untuk sebagian besar layanan. Dalam contoh berikut, `httpResponse` properti `AWS.Response` objek digunakan dalam fungsi callback untuk mencatat data respons mentah dan header untuk membantu debugging.
```
new AWS.EC2({apiVersion: '2014-10-01'}).describeInstances(function(error, data) {
if (error) {
console.log(error); // an error occurred
// Using this keyword to access AWS.Response object and properties
console.log("Response data and headers: " + JSON.stringify(this.httpResponse));
} else {
console.log(data); // request succeeded
}
});
```
Selain itu, karena `AWS.Response` objek memiliki `Request` properti yang berisi `AWS.Request` yang dikirim oleh panggilan metode asli, Anda juga dapat mengakses detail permintaan yang dibuat.
# Menggunakan Request Object Event Listener
Jika Anda tidak membuat dan meneruskan fungsi callback anonim sebagai parameter saat Anda memanggil metode objek layanan, panggilan metode menghasilkan `AWS.Request` objek yang harus dikirim secara manual menggunakan `send` metodenya.
Untuk memproses respons, Anda harus membuat event listener untuk `AWS.Request` objek untuk mendaftarkan fungsi callback untuk panggilan metode. Contoh berikut menunjukkan cara membuat `AWS.Request` objek untuk memanggil metode objek layanan dan pendengar acara untuk pengembalian yang berhasil.
```
// 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();
```
Setelah `send` metode pada `AWS.Request` objek dipanggil, event handler mengeksekusi ketika objek layanan menerima objek`AWS.Response`.
Untuk informasi selengkapnya tentang `AWS.Request` objek, lihat [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)di Referensi API. Untuk informasi selengkapnya tentang `AWS.Response` objek, lihat [Menggunakan Response Object](the-response-object.md) atau [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Response.html)di Referensi API.
## Merantai Beberapa Panggilan Balik
Anda dapat mendaftarkan beberapa callback pada objek permintaan apa pun. Beberapa panggilan balik dapat didaftarkan untuk acara yang berbeda atau acara yang sama. Selain itu, Anda dapat menghubungkan callback seperti yang ditunjukkan pada contoh berikut.
```
request.
on('success', function(response) {
console.log("Success!");
}).
on('error', function(response) {
console.log("Error!");
}).
on('complete', function() {
console.log("Always!");
}).
send();
```
## Permintaan Acara Penyelesaian Objek
`AWS.Request`Objek memunculkan peristiwa penyelesaian ini berdasarkan respons dari setiap metode operasi layanan:
+ `success`
+ `error`
+ `complete`
Anda dapat mendaftarkan fungsi callback sebagai respons terhadap salah satu peristiwa ini. Untuk daftar lengkap semua peristiwa objek permintaan, lihat [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)di Referensi API.
### Acara Sukses
`success`Acara ini diangkat setelah respons yang berhasil diterima dari objek layanan. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('success', function(response) {
// event handler code
});
```
Respons menyediakan `data` properti yang berisi data respons serial dari layanan. Misalnya, panggilan berikut ke `listBuckets` metode objek layanan Amazon S3
```
s3.listBuckets.on('success', function(response) {
console.log(response.data);
}).send();
```
mengembalikan respon dan kemudian mencetak konten `data` properti berikut ke konsol.
```
{ Owner: { ID: '...', DisplayName: '...' },
Buckets:
[ { Name: 'someBucketName', CreationDate: someCreationDate },
{ Name: 'otherBucketName', CreationDate: otherCreationDate } ],
RequestId: '...' }
```
### Peristiwa kesalahan
`error`Acara ini dimunculkan pada respons kesalahan yang diterima dari objek layanan. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('error', function(error, response) {
// event handling code
});
```
Ketika `error` acara dinaikkan, nilai `data` properti respon adalah `null` dan `error` properti berisi data kesalahan. `error`Objek terkait diteruskan sebagai parameter pertama ke fungsi callback terdaftar. Misalnya, kode berikut:
```
s3.config.credentials.accessKeyId = 'invalid';
s3.listBuckets().on('error', function(error, response) {
console.log(error);
}).send();
```
mengembalikan kesalahan dan kemudian mencetak data kesalahan berikut ke konsol.
```
{ code: 'Forbidden', message: null }
```
### Acara Lengkap
`complete`Acara dimunculkan ketika panggilan objek layanan telah selesai, terlepas dari apakah panggilan tersebut menghasilkan keberhasilan atau kesalahan. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('complete', function(response) {
// event handler code
});
```
Gunakan callback `complete` acara untuk menangani pembersihan permintaan apa pun yang harus dijalankan terlepas dari keberhasilan atau kesalahan. Jika Anda menggunakan data respons di dalam callback untuk `complete` acara tersebut, periksa dulu `response.error` properti `response.data` atau sebelum mencoba mengakses salah satu, seperti yang ditunjukkan pada contoh berikut.
```
request.on('complete', function(response) {
if (response.error) {
// an error occurred, handle it
} else {
// we can use response.data here
}
}).send();
```
## Permintaan Objek Acara HTTP
`AWS.Request`Objek memunculkan peristiwa HTTP ini berdasarkan respons dari setiap metode operasi layanan:
+ `httpHeaders`
+ `httpData`
+ `httpUploadProgress`
+ `httpDownloadProgress`
+ `httpError`
+ `httpDone`
Anda dapat mendaftarkan fungsi callback sebagai respons terhadap salah satu peristiwa ini. Untuk daftar lengkap semua peristiwa objek permintaan, lihat [https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/Request.html)di Referensi API.
### Acara HttpHeaders
`httpHeaders`Acara ini dinaikkan ketika header dikirim oleh server jarak jauh. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpHeaders', function(statusCode, headers, response) {
// event handling code
});
```
`statusCode`Parameter untuk fungsi callback adalah kode status HTTP. `headers`Parameter berisi header respons.
### Acara HttpData
`httpData`Acara ini dinaikkan untuk mengalirkan paket data respons dari layanan. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpData', function(chunk, response) {
// event handling code
});
```
Acara ini biasanya digunakan untuk menerima respons besar dalam potongan saat memuat seluruh respons ke dalam memori tidak praktis. Acara ini memiliki `chunk` parameter tambahan yang berisi sebagian data aktual dari server.
Jika Anda mendaftarkan callback untuk `httpData` acara tersebut, `data` properti respons berisi seluruh keluaran serial untuk permintaan tersebut. Anda harus menghapus `httpData` pendengar default jika Anda tidak memiliki parsing tambahan dan overhead memori untuk penangan bawaan.
### httpUploadProgress dan httpDownloadProgress Peristiwa
`httpUploadProgress`Acara ini muncul ketika permintaan HTTP telah mengunggah lebih banyak data. Demikian pula, `httpDownloadProgress` acara dinaikkan ketika permintaan HTTP telah mengunduh lebih banyak data. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpUploadProgress', function(progress, response) {
// event handling code
})
.on('httpDownloadProgress', function(progress, response) {
// event handling code
});
```
`progress`Parameter ke fungsi callback berisi objek dengan byte yang dimuat dan total permintaan.
### Acara HttpError
`httpError`Acara dimunculkan ketika permintaan HTTP gagal. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpError', function(error, response) {
// event handling code
});
```
`error`Parameter ke fungsi callback berisi kesalahan yang dilemparkan.
### Acara HttpDone
`httpDone`Acara ini dinaikkan ketika server selesai mengirim data. Berikut adalah cara Anda mendaftarkan fungsi callback untuk acara ini.
```
request.on('httpDone', function(response) {
// event handling code
});
```
# Menggunakan async/await
Anda dapat menggunakan `async/await` pola dalam panggilan Anda ke file AWS SDK untuk JavaScript. Sebagian besar fungsi yang mengambil panggilan balik tidak mengembalikan janji. Karena Anda hanya menggunakan `await` fungsi yang mengembalikan janji, untuk menggunakan `async/await` pola Anda perlu menghubungkan `.promise()` metode ke akhir panggilan Anda, dan menghapus panggilan balik.
Contoh berikut digunakan async/await untuk mencantumkan semua tabel Amazon DynamoDB Anda di. `us-west-2`
```
var AWS = require("aws-sdk");
//Create an Amazon DynamoDB client service object.
dbClient = new AWS.DynamoDB({ region: "us-west-2" });
// Call DynamoDB to list existing tables
const run = async () => {
try {
const results = await dbClient.listTables({}).promise();
console.log(results.TableNames.join("\n"));
} catch (err) {
console.error(err);
}
};
run();
```
**catatan**
Tidak semua browser mendukung async/await. Lihat [Fungsi async](https://caniuse.com/#feat=async-functions) untuk daftar browser dengan async/await dukungan.
# Menggunakan JavaScript Janji
`AWS.Request.promise`Metode ini menyediakan cara untuk memanggil operasi layanan dan mengelola aliran asinkron alih-alih menggunakan callback. Dalam Node.js dan skrip browser, `AWS.Request` objek dikembalikan ketika operasi layanan dipanggil tanpa fungsi callback. Anda dapat memanggil `send` metode permintaan untuk melakukan panggilan layanan.
Namun, `AWS.Request.promise` segera mulai panggilan layanan dan mengembalikan janji yang dipenuhi dengan `data` properti respons atau ditolak dengan `error` properti respons.
```
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 */
}
);
```
Contoh berikutnya mengembalikan janji yang dipenuhi dengan `data` objek, atau ditolak dengan `error` objek. Menggunakan janji, satu panggilan balik tidak bertanggung jawab untuk mendeteksi kesalahan. Sebagai gantinya, callback yang benar dipanggil berdasarkan keberhasilan atau kegagalan permintaan.
```
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);
});
```
## Koordinasi Beberapa Janji
Dalam beberapa situasi, kode Anda harus membuat beberapa panggilan asinkron yang memerlukan tindakan hanya jika semuanya berhasil dikembalikan. Jika Anda mengelola panggilan metode asinkron individual tersebut dengan janji, Anda dapat membuat janji tambahan yang menggunakan metode ini. `all` Metode ini memenuhi janji payung ini jika dan ketika berbagai janji yang Anda berikan ke metode terpenuhi. Fungsi callback dilewatkan sebuah array dari nilai-nilai dari janji-janji yang diteruskan ke `all` metode.
Dalam contoh berikut, AWS Lambda fungsi harus membuat tiga panggilan asinkron ke Amazon DynamoDB tetapi hanya dapat diselesaikan setelah janji untuk setiap panggilan terpenuhi.
```
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 dan Node.js Support for Promises
Support for native JavaScript promises (ECMAScript 2015) tergantung pada JavaScript mesin dan versi di mana kode Anda dijalankan. Untuk membantu menentukan dukungan untuk JavaScript janji di setiap lingkungan tempat kode Anda perlu dijalankan, lihat [Tabel ECMAScript Kompatibilitas](https://compat-table.github.io/compat-table/es6/) di. GitHub
## Menggunakan Implementasi Janji Lainnya
Selain implementasi janji asli pada tahun ECMAScript 2015, Anda juga dapat menggunakan pustaka janji pihak ketiga, termasuk:
+ [burung biru](http://bluebirdjs.com)
+ [RSVP](https://github.com/tildeio/rsvp.js/)
+ [Q](https://github.com/kriskowal/q)
Pustaka janji opsional ini dapat berguna jika Anda memerlukan kode Anda untuk berjalan di lingkungan yang tidak mendukung implementasi janji asli di ECMAScript 5 dan ECMAScript 2015.
Untuk menggunakan pustaka janji pihak ketiga, tetapkan dependensi janji pada SDK dengan memanggil `setPromisesDependency` metode objek konfigurasi global. Dalam skrip browser, pastikan untuk memuat pustaka janji pihak ketiga sebelum memuat SDK. Dalam contoh berikut, SDK dikonfigurasi untuk menggunakan implementasi di pustaka janji bluebird.
```
AWS.config.setPromisesDependency(require('bluebird'));
```
Untuk kembali menggunakan implementasi janji asli JavaScript mesin, panggil `setPromisesDependency` lagi, berikan nama `null` alih-alih perpustakaan.