(i18n) translate article of network/fetch-abort into indonesian

Author: babul28

5-network/04-fetch-abort/article.md

@@ -1,148 +1,150 @@
+# Fetch: Membatalkan
 
-# Fetch: Abort
+Seperti yang kita tahu, `fetch` mengembalikan `promise` dan Javascript secara umum tidak memiliki konsep untuk "membatalkan" sebuah janji (`Promise`). Jadi, bagaimana kita bisa membatalkan `fetch` yang sedang dijalankan? misalnya, jika tindakan pengguna pada situs kita mengindikasikan bahwa `fetch` sudah tidak dibutuhkan lagi.
 
-As we know, `fetch` returns a promise. And JavaScript generally has no concept of "aborting" a promise. So how can we cancel an ongoing `fetch`? E.g. if the user actions on our site indicate that the `fetch` isn't needed any more.
+Terdapat objek bawaan khusus untuk tujuan ini: `AbortContoller`. Metode tersebut dapat digunakan untuk membatalkan tidak hanya `fetch`, tetapi tugas asingkron lainnya.
 
-There's a special built-in object for such purposes: `AbortController`. It can be used to abort not only `fetch`, but other asynchronous tasks as well.
+Penggunaannya sangat mudah:
 
-The usage is very straightforward:
+## Objek AbortController
 
-## The AbortController object
-
-Create a controller:
+Membuat sebuah pengontrol (_controller_)
 
 ```js
 let controller = new AbortController();
 ```
 
-A controller is an extremely simple object.
+Pengontrol adalah objek yang sangat sederhana.
+
+- Hanya memiliki satu metode `abort()`,
+- dan sebuah properti `signal` yang memungkinkan untuk menyetel `listener` pada objek pengontrol.
 
-- It has a single method `abort()`,
-- And a single property `signal` that allows to set event liseners on it.
+Ketika `abort()` dipanggil:
 
-When `abort()` is called:
-- `controller.signal` emits the `"abort"` event.
-- `controller.signal.aborted` property becomes `true`.
+- `contoller.signal` mengeluarkan _event_ `"abort"`
+- Properti `controller.signal.aborted` menjadi bernilai `true`
 
-Generally, we have two parties in the process: 
-1. The one that performs an cancelable operation, it sets a listener on `controller.signal`.
-2. The one one that cancels: it calls `controller.abort()` when needed.
+Secara Umum, kita memiliki dua pihak dalam prosesnya:
 
-Here's the full example (without `fetch` yet):
+1. Satu pihak yang melaksanakan tindakan terntentu ketika operasi dibatalkan, itu menyetel _listener_ pada `controller.signal`.
+2. Satu pihak lainnya yang membatalkan: itu memanggil `controller.abort()` ketika diperlukan.
+
+Berikut contoh lengkapnya (tanpa `fetch`)
 
 ```js run
 let controller = new AbortController();
 let signal = controller.signal;
 
-// The party that performs a cancelable operation 
-// gets "signal" object
-// and sets the listener to trigger when controller.abort() is called
-signal.addEventListener('abort', () => alert("abort!"));
+// Pihak yang melakukan tindakan tertentu ketika operasi dibatalkan
+// mendapatkan objek "signal"
+// dan menyetel 'listener' untuk memicu ketika controller.abort() dipanggil
+signal.addEventListener('abort', () => alert('abort!'));
 
-// The other party, that cancels (at any point later):
-controller.abort(); // abort!
+// Pihak lain yang membatalkan (penjelasnnya nanti)
+controller.abort(); // gagalkan!
 
-// The event triggers and signal.aborted becomes true
+// Pemicu 'event' dan nilai 'signal.aborted' menjadi 'true'
 alert(signal.aborted); // true
 ```
 
-As we can see, `AbortController` is just a means to pass `abort` events when `abort()` is called on it.
+Seperti yang kita lihat, `AbortController` hanyalah sarana untuk meneruskan _event_ `abort()` ketika dipanggil.
 
-We could implement same kind of event listening in our code on our own, without `AbortController` object at all.
+Kita dapat mengimplementasikan jenis _event listener_ yang sama pada kode kita, walaupun tanpa objek `AbortController` sama sekali.
 
-But what's valuable is that `fetch` knows how to work with `AbortController` object, it's integrated with it. 
+Tetapi yang berharga adalah `fetch` tahu bagaimana bekerja dengan objek `AborController`, itu terintegrasi dengannya.
 
-## Using with fetch
+## Menggunakan dengan fetch
 
-To become able to cancel `fetch`, pass the `signal` property of an `AbortController` as a `fetch` option:
+Untuk bisa membatalkan `fetch`, teruskan properti `signal` dari `AbortController` sebagai opsi `fetch`:
 
 ```js
 let controller = new AbortController();
 fetch(url, {
-  signal: controller.signal
+  signal: controller.signal,
 });
 ```
 
-The `fetch` method knows how to work with `AbortController`. It will listen to `abort` events on `signal`.
+Metode `fetch` mengetahui bagaimana cara bekerja dengan `AbortController`. Itu akan mendengarkan (_listen_) _event_ `abort` pada properti `signal`.
 
-Now, to to abort, call `controller.abort()`:
+Sekarang, untuk membatalkannya, panggil `controller.abort()`:
 
 ```js
 controller.abort();
 ```
 
-We're done: `fetch` gets the event from `signal` and aborts the request.
+Kita sudah selesai: `fetch` mendapatkan _event_ dari properti `signal` dan membatalkan _request_.
 
-When a fetch is aborted, its promise rejects with an error `AbortError`, so we should handle it, e.g. in `try..catch`.
+Ketika `fetch` dibatalkan, maka `promise` akan ditolak dengan galat `AboutError`, jadi kita dapat menanganinya. Misalnya dengan `try ... catch`.
 
-Here's the full example with `fetch` aborted after 1 second:
+Berikut adalah contoh penuh untuk menggagalkan `fetch` setelah 1 detik:
 
 ```js run async
-// abort in 1 second
+// gagalkan setelah satu detik
 let controller = new AbortController();
 setTimeout(() => controller.abort(), 1000);
 
 try {
   let response = await fetch('/article/fetch-abort/demo/hang', {
-    signal: controller.signal
+    signal: controller.signal,
   });
-} catch(err) {
-  if (err.name == 'AbortError') { // handle abort()
-    alert("Aborted!");
+} catch (err) {
+  if (err.name == 'AbortError') {
+    // menangani ketika digagalkan
+    alert('Aborted!');
   } else {
     throw err;
   }
 }
 ```
 
-## AbortController is scalable
+## AbortController dapat ditingkatkan (_scalable_)
 
-`AbortController` is scalable, it allows to cancel multiple fetches at once.
+`AbortContoller` bersifat _scalable_, itu memungkinkan untuk membatalkan beberapa `fetch` sekaligus.
 
-Here's a sketch of code that fetches many `urls` in parallel, and uses a single controller to abort them all:
+Berikut adalah sketsa dari kode yang terdapat proses `fetch` ke banyak `urls` secara paralel, dan menggunakan pengontrol tunggal untuk membatalkan semua proses tersebut:
 
 ```js
-let urls = [...]; // a list of urls to fetch in parallel
+let urls = [...]; // daftar dari url yang akan diambil secara paralel
 
 let controller = new AbortController();
 
-// an array of fetch promises
+// larik dari 'fetch promise'
 let fetchJobs = urls.map(url => fetch(url, {
   signal: controller.signal
 }));
 
 let results = await Promise.all(fetchJobs);
 
-// if controller.abort() is called from elsewhere,
-// it aborts all fetches
+// jika controller.fetch() dipanggil dari tempat tertentu
+// itu akan menggagalkan semua 'fetch'
 ```
 
-If we have our own asynchronous tasks, different from `fetch`, we can use a single `AbortController` to stop those, together with fetches.
+Jika kita memiliki tugas asingkron kita sendiri yang berbeda dari `fetch`, kita dapat menggunakan `AbortController` tunggal untuk menghentikannya, bersama dengan metode `fetch`.
 
-We just need to listen to its `abort` event in our tasks:
+Kita hanya perlu untuk `listen` pada _event_ `abort` di tugas kita;
 
 ```js
 let urls = [...];
 let controller = new AbortController();
 
-let ourJob = new Promise((resolve, reject) => { // our task
+let ourJob = new Promise((resolve, reject) => { // tugas kita
   ...
   controller.signal.addEventListener('abort', reject);
 });
 
-let fetchJobs = urls.map(url => fetch(url, { // fetches
+let fetchJobs = urls.map(url => fetch(url, { // pemanggilan metode fetch
   signal: controller.signal
 }));
 
-// Wait for fetches and our task in parallel
+// Menunggu semua metode fetch dan tugas kita secara paralel
 let results = await Promise.all([...fetchJobs, ourJob]);
 
-// if controller.abort() is called from elsewhere,
-// it aborts all fetches and ourJob
+// Jika controller.abort() dipanggil dari suatu tempat,
+// itu menggagalkan semua metode fetch dan tugas kita
 ```
 
-## Summary
+## Kesimpulan
 
-- `AbortController` is a simple object that generates `abort` event on it's `signal` property when `abort()` method is called (and also sets `signal.aborted` to `true`).
-- `fetch` integrates with it: we pass `signal` property as the option, and then `fetch` listens to it, so it becomes possible to abort the `fetch`.
-- We can use `AbortController` in our code. The "call `abort()`" -> "listen to `abort` event" interaction is simple and universal. We can use it even without `fetch`.
+- `AbortController` adalah sebuah objek sederhana yang menghasilkan _event_ `abort` pada properti `signal` ketika metode `abort()` dipanggil (dan juga menyetel `signal.aborted` menjadi `true`).
+- `fetch` terintegrasi dengannya: kita meneruskan properti `signal` sebagai opsi, dan kemudian `fetch` mendengarkan event yang dihasilkan `AbortController`. Jadi itu menjadi mungkin ketika ingin menggagalkan proses `fetch`.
+- Kita dapat menggunakan `AbortConntroller` pada kode kita. Interaksi "pemanggilan `abort()`" -> "Mendengarkan (_listen_) _event_ `abort`" sederhana dan universal. Kita dapat menggunakannya walaupun tanpa `fetch`.