Kegiatan Belajar
A. ASYNCHRONOUS PROGRAMMING
2. Implementasi Asynchronous Programming pada TypeScript
Pada umumnya, TypeScript menggunakan teknik Promise serta Async/Await untuk mengelola asynchronous programming. Sebenarnya dapat juga menggunakan callback tetapi callback ini sama sekali tidak disarankan karena kompleksitas dari callback pada saat proses debugging sehingga tidak dibahas di buku materi pokok ini. Pada BMP ini proses Async/Await menggunakan teknik Promise dalam proses implementasinya meskipun dapat juga tidak secara eksplisit menggunakan Promise.
a. Promise
Sama seperti halnya dalam kehidupan sehari-hari, promise atau janji merupakan suatu kejadian yang diharapkan akan terjadi di masa yang akan datang. Normalnya, janji akan dipenuhi tetapi belum tentu akan terjadi seperti yang dijanjikan. Kondisi semacam ini sering kali terjadi saat kita membuat software. Contoh:
1) Mengakses suatu endpoint di Internet (URL tertentu). Normalnya kita dapat mengakses endpoint tersebut, tetapi dapat saja Internet mati, atau alamat URL tersebut berpindah, dan kemungkinan-kemungkinan lain.
2) Membaca suatu file di lokasi tertentu. Normalnya kita dapat membaca file tersebut, namun bisa terjadi file tersebut rusak, atau sudah dihapus, atau tidak memiliki hak akses untuk membaca, dan lain-lain.
3) Melakukan query ke suatu DBMS. Normalnya kita dapat melakukan query dan berharap mendapatkan hasilnya, tetapi dapat saja query kita salah, atau hak akses kita dibatasi, dan lain-lain.
Dalam kondisi-kondisi seperti tersebut di atas, seorang pemrogram harus mengantisipasi dengan menggunakan konstruksi bahasa pemrograman tertentu.
Ada 2 hal yang harus diantisipasi terkait asynchronous programming ini, yaitu:
1) Kemungkinan latensi atau waktu akses yang relatif lama.
2) Kemungkinan kegagalan operasi, baik di awal maupun setelah terjadi proses dan kegagalan ini tidak dapat kita prediksi di awal.
Dengan menggunakan TypeScript, kita dapat menggunakan Promise maupun async/await untuk mengantisipasi kedua hal tersebut. Contoh dari Promise dapat dilihat pada Listing 1.19.
function getAngkaAcak(max: number): number { // <1>
return Math.floor(Math.random() * Math.floor(max));
}
let p = new Promise<unknown>((resolve, reject) => { // <2>
let acak = getAngkaAcak(1000);
if (acak > 500) {
resolve(true); // <3>
return;
}
reject(“Hasil < = 500”); // <4>
});
console.log(p); // <5>
p.catch(err => console.log(“ERROR - “, err)); // <6>
// Berbagai kemungkinan saat run:
// Promise { true }
// -> jika angka random lebih besar dari 500 // Promise { <rejected> ‘Hasil < = 500’ } // ERROR - Hasil < = 500
// -> jika yang terjadi adalah reject
Listing 1.19
Penggunaan Promise Untuk Asynchronous Programming.
1) Mendefinisikan fungsi getAngkaAcak yang akan digunakan untuk mendapatkan angka acak dengan nilai maksimal tertentu. Fungsi ini akan digunakan pada baris-baris berikutnya.
2) Membuat obyek Promise dengan generics kita isi unknown karena kita belum mengetahui hasil dari proses.
3) Disini terdapat 2 argumen yakni resolve dan reject.
4) Resolve akan dikerjakan jika promise is fulfilled atau janji ditepati atau proses yang kita inginkan terjadi di masa yang akan datang selesai dengan baik. Jika terjadi sesuatu error, maka yang akan dikerjakan adalah reject.
5) Jika hasil sesuai dengan yang diinginkan (acak > 500), maka yang akan dikerjakan adalah resolve, dalam hal ini hanya mengembalikan nilai true.
6) Jika hasil tidak sesuai dengan yang diinginkan (acak <= 500), maka yang akan dikerjakan adalah reject.
7) Menampilkan hasil.
8) Jika terjadi error / reject, maka bagian tersebut dapat kita antisipasi dengan catch.
b. Promise Chaining
Namun ada kalanya, pengerjaan satu tindakan dalam Promise saja tidak cukup, tetapi diperlukan suatu rangkaian yang akan menyusul proses yang telah berhasil dikerjakan tersebut. Sebagai contoh, kita dapat membaca suatu file CSV kemudian mengambil kolom pertama baris pertama kemudian mentransformasikan isinya sesuai dengan rumus tertentu. Dalam kasus seperti ini, diperlukan chaining atau merangkai satu proses dengan proses lainnya. Hasil satu proses merupakan input bagi proses berikutnya, demikian seterusnya. TypeScript memungkinkan melakukan hal tersebut dengan menggunakan promise chaining, seperti yang tertera pada Listing 1.20
function getAngkaAcak(max: number): number { return Math.floor(Math.random() * Math.floor(max));
}
let p = new Promise<number>((resolve, reject) => { let acak = getAngkaAcak(20);
let hasil: number; // <1>
if (acak > 10) { resolve(acak);
return;
}
reject(“Hasil < = 10”);
}).then(function(hasil) { // <2>
}).then(function(hasil) { console.log(hasil);
return hasil*2;
});
console.log(p);
p.catch(err => console.log(“ERROR - “, err));
// run (dapat berbeda-beda):
// pertama (jika resolve):
// Promise { <pending> } // 12
// 24 // 48
// kedua (jika reject):
// Promise { <pending> } // ERROR - Hasil < = 10
Listing 1.20 Promise Chaining
1) Menyiapkan variabel hasil yang nantinya akan digunakan untuk menampung hasil dari bilangan acak jika sesuai dengan kondisi (> 10).
2) Chain pertama, jika > 10 maka hasil bilangan acak tersebut akan diletakkan ke variabel hasil.
3) Setelah itu isi variabel hasil akan ditampilkan.
4) Variabel hasil kemudian dikalikan 2. Hasil perkalian tersebut dijadikan nilai kembalian yang akan digunakan oleh chain berikutnya. Misal acak berisi 12, maka hasil akan diisi 12 dan kemudian ditampilkan serta dikalikan 2.
Hasil perkalian tersebut (24) akan dijadikan nilai kembalian dan menjadi masukan bagi chain berikutnya.
5) Mengambil nilai dari nilai kembalian chain sebelumnya, yaitu 24 dan kemudian dimasukkan ke variabel hasil.
6) Menampilkan nilai variabel hasil (24).
7) Sama dengan penjelasan nomor 4, tetapi untuk chain berikutnya.
c. Async/Await
Konstruksi async/await pada dasarnya digunakan untuk pemanis sintaksis dari asynchronous programming yang dirasakan relatif membuat kode sumber yang dibuat susah dibaca.
Pola pikir untuk menggunakan konstruksi ini adalah:
1) Buat fungsi yang akan di dalam badan fungsi tersebut terdapat operasi asynchronous.
2) Letakkan async di depan function.
3) Di dalam badan fungsi tersebut, gunakan await untuk operasi yang memerlukan penanganan asynchronous.
4) Letakkan await dalam kerangka try … catch. Jika berhasil maka bagian try akan dikerjakan. Jika error, maka bagian catch akan menangkap error tersebut.
Contoh dari penggunaan async/await dapat dilihat pada Listing 1.21.
function getAngkaAcak(max: number): number { // <1>
return Math.floor(Math.random() * Math.floor(max));
}
function lebihDari(max: number, angka: number): boolean | number { // <2>
if (angka > max) {
throw “ERR: arg 1 harus lebih besar daripada arg 2”
}
let acak = getAngkaAcak(max);
if (acak > angka) { return true;
} else { return acak;
} }
let p = async function (): Promise<boolean | number> { // <3>
try {
//let hasilOK: boolean | number = await lebihDari(100, 500); // <4>
let hasilOK: boolean | number = await lebihDari(1000, 500); // <5>
return hasilOK;
} catch(error) { // <6>
return error;
} };
(async () => { // <7>
console.log(await p()) })()
// jika <4> di uncomment, maka hasil:
// ERR: arg 1 harus lebih besar daripada arg 2 // jika menggunakan <5>, maka hasil kemungkinan:
// true
// 134 (atau angka lain)
Listing 1.21 Penggunaan Async/Await
1) Mendefinisikan fungsi untuk mencari nilai acak dengan nilai maksimal tertentu.
2) Mendefinisikan fungsi untuk membandingkan apakah suatu nilai acak dengan nilai maksimal tertentu (argumen 1) lebih besar daripada nilai tertentu (argumen 2). Jika penggunaan fungsi ini salah maka akan dihasilkan error (throw).
3) Fungsi p akan menghasilkan Promise dengan nilai kembalian berupa union (boolean atau angka / number).
4) Await akan diletakkan pada konstruksi try … catch. Jika baris ini digunakan maka akan menghasilkan error, sehingga akan ditangkap oleh catch.
5) Await yang ada pada bagian ini digunakan untuk mengerjakan lebihDari dan kemudian menempatkan hasilnya ke hasilOK. Perlu diketahui, saat proses dijalankan, bagian ini akan dijadikan Promise dan baru akan dikembalikan lagi setelah ada hasil.
6) Jika terjadi error, maka bagian ini akan dikerjakan.
7) Bagian ini digunakan untuk mengambil hasil dari proses async/await yang sudah didefinisikan di p.