docs: network/04-fetch-abort 번역 작업

Author: gusdn3477

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

@@ -1,87 +1,60 @@
 
-# Fetch: Abort
+# Fetch: 요청 중단하기
 
-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.
+`fetch`는 프라미스를 반환합니다. 그런데 자바스크립트에는 일반적으로 프라미스를 '중단'한다는 개념이 없습니다. 그렇다면 진행 중인 `fetch`는 어떻게 취소할 수 있을까요? 예를 들어 사이트에서 사용자 행동을 보고 더 이상 `fetch`가 필요 없다고 판단한 경우처럼 말이죠.
 
-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.
+이런 목적을 위해 만들어진 특별한 내장 객체가 있습니다. 바로 `AbortController`입니다. `AbortController`를 사용하면 `fetch`뿐만 아니라 다른 비동기 작업도 중단할 수 있습니다.
 
-The usage is very straightforward:
+사용법은 아주 간단합니다.
 
-## The AbortController object
+## AbortController 객체
 
-Create a controller:
+컨트롤러를 하나 만듭니다.
 
 ```js
 let controller = new AbortController();
 ```
 
-A controller is an extremely simple object.
+컨트롤러는 아주 단순한 객체입니다.
 
-- It has a single method `abort()`,
-<<<<<<< HEAD
-- And a single property `signal` that allows to set event liseners on it.
-=======
-- And a single property `signal` that allows to set event listeners on it.
->>>>>>> upstream/master
+- 메서드는 `abort()` 하나뿐입니다.
+- 이벤트 리스너를 설정할 수 있는 프로퍼티도 `signal` 하나뿐입니다.
 
-When `abort()` is called:
-- `controller.signal` emits the `"abort"` event.
-- `controller.signal.aborted` property becomes `true`.
+`abort()`가 호출되면 다음 일이 일어납니다.
+- `controller.signal`에서 `"abort"` 이벤트가 발생합니다.
+- `controller.signal.aborted` 프로퍼티 값이 `true`가 됩니다.
 
-<<<<<<< HEAD
-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.
-=======
-Generally, we have two parties in the process:
-1. The one that performs a cancelable operation, it sets a listener on `controller.signal`.
-2. The one that cancels: it calls `controller.abort()` when needed.
->>>>>>> upstream/master
+보통 이 과정에는 두 주체가 있습니다.
+1. 취소 가능한 작업을 수행하는 쪽은 `controller.signal`에 리스너를 설정합니다.
+2. 취소하는 쪽은 필요할 때 `controller.abort()`를 호출합니다.
 
-Here's the full example (without `fetch` yet):
+전체 예시를 살펴봅시다. 아직 `fetch`는 사용하지 않습니다.
 
 ```js run
 let controller = new AbortController();
 let signal = controller.signal;
 
-<<<<<<< HEAD
-// The party that performs a cancelable operation 
-// gets "signal" object
-=======
-// The party that performs a cancelable operation
-// gets the "signal" object
->>>>>>> upstream/master
-// and sets the listener to trigger when controller.abort() is called
-signal.addEventListener('abort', () => alert("abort!"));
+// 취소 가능한 작업을 수행하는 쪽은
+// "signal" 객체를 받고,
+// controller.abort()가 호출되었을 때 실행될 리스너를 설정합니다.
+signal.addEventListener('abort', () => alert("중단!"));
 
-// The other party, that cancels (at any point later):
-controller.abort(); // abort!
+// 취소하는 쪽은 나중에 언제든 다음을 호출합니다.
+controller.abort(); // 중단!
 
-// The event triggers and signal.aborted becomes true
+// 이벤트가 발생하고 signal.aborted가 true가 됩니다.
 alert(signal.aborted); // true
 ```
 
-<<<<<<< HEAD
-As we can see, `AbortController` is just a means to pass `abort` events when `abort()` is called on it.
+예시에서 볼 수 있듯이 `AbortController`는 `abort()`가 호출되었을 때 `abort` 이벤트를 전달하는 수단입니다.
 
-We could implement same kind of event listening in our code on our own, without `AbortController` object at all.
+`AbortController` 객체 없이도 코드에서 이런 이벤트 리스닝 방식을 직접 구현할 수 있습니다.
 
-But what's valuable is that `fetch` knows how to work with `AbortController` object, it's integrated with it. 
+하지만 중요한 점은 `fetch`가 `AbortController` 객체와 함께 동작하는 방법을 알고 있다는 것입니다. `fetch`와 `AbortController`는 통합되어 있습니다.
 
-## Using with fetch
+## fetch와 함께 사용하기
 
-To become able to cancel `fetch`, pass the `signal` property of an `AbortController` as a `fetch` option:
-=======
-As we can see, `AbortController` is just a mean to pass `abort` events when `abort()` is called on it.
-
-We could implement the same kind of event listening in our code on our own, without the `AbortController` object.
-
-But what's valuable is that `fetch` knows how to work with the `AbortController` object. It's integrated in it.
-
-## Using with fetch
-
-To be able to cancel `fetch`, pass the `signal` property of an `AbortController` as a `fetch` option:
->>>>>>> upstream/master
+`fetch`를 취소할 수 있게 하려면 `AbortController`의 `signal` 프로퍼티를 `fetch` 옵션으로 넘기면 됩니다.
 
 ```js
 let controller = new AbortController();
@@ -90,26 +63,22 @@ fetch(url, {
 });
 ```
 
-The `fetch` method knows how to work with `AbortController`. It will listen to `abort` events on `signal`.
+`fetch` 메서드는 `AbortController`와 함께 동작하는 방법을 알고 있습니다. `fetch`는 `signal`의 `abort` 이벤트를 감지합니다.
 
-<<<<<<< HEAD
-Now, to to abort, call `controller.abort()`:
-=======
-Now, to abort, call `controller.abort()`:
->>>>>>> upstream/master
+이제 중단하려면 `controller.abort()`를 호출하면 됩니다.
 
 ```js
 controller.abort();
 ```
 
-We're done: `fetch` gets the event from `signal` and aborts the request.
+이게 전부입니다. `fetch`가 `signal`로부터 이벤트를 받아 요청을 중단합니다.
 
-When a fetch is aborted, its promise rejects with an error `AbortError`, so we should handle it, e.g. in `try..catch`.
+`fetch`가 중단되면 해당 프라미스는 `AbortError` 에러와 함께 거부됩니다. 따라서 `try..catch` 등으로 이를 처리해야 합니다.
 
-Here's the full example with `fetch` aborted after 1 second:
+다음은 1초 후 `fetch`를 중단하는 전체 예시입니다.
 
 ```js run async
-// abort in 1 second
+// 1초 후 중단
 let controller = new AbortController();
 setTimeout(() => controller.abort(), 1000);
 
@@ -118,71 +87,62 @@ try {
     signal: controller.signal
   });
 } catch(err) {
-  if (err.name == 'AbortError') { // handle abort()
-    alert("Aborted!");
+  if (err.name == 'AbortError') { // abort() 처리
+    alert("중단되었습니다!");
   } else {
     throw err;
   }
 }
 ```
 
-## AbortController is scalable
+## AbortController는 확장성이 좋습니다
 
-<<<<<<< HEAD
-`AbortController` is scalable, it allows to cancel multiple fetches at once.
-=======
-`AbortController` is scalable. It allows to cancel multiple fetches at once.
->>>>>>> upstream/master
+`AbortController`는 확장성이 좋습니다. 여러 `fetch`를 한꺼번에 취소할 수 있습니다.
 
-Here's a sketch of code that fetches many `urls` in parallel, and uses a single controller to abort them all:
+다음은 여러 `url`을 병렬로 가져오고, 하나의 컨트롤러로 모든 요청을 중단하는 코드 예시입니다.
 
 ```js
-let urls = [...]; // a list of urls to fetch in parallel
+let urls = [...]; // 병렬로 가져올 url 목록
 
 let controller = new AbortController();
 
-// an array of fetch promises
+// fetch 프라미스 배열
 let fetchJobs = urls.map(url => fetch(url, {
   signal: controller.signal
 }));
 
 let results = await Promise.all(fetchJobs);
 
-// if controller.abort() is called from anywhere,
-// it aborts all fetches
+// 어디서든 controller.abort()가 호출되면
+// 모든 fetch가 중단됩니다.
 ```
 
-If we have our own asynchronous tasks, different from `fetch`, we can use a single `AbortController` to stop those, together with fetches.
+`fetch`와는 다른 자체 비동기 작업이 있다면 하나의 `AbortController`를 사용해 해당 작업과 `fetch`를 함께 멈출 수 있습니다.
 
-We just need to listen to its `abort` event in our tasks:
+작업 안에서 `abort` 이벤트를 감지하기만 하면 됩니다.
 
 ```js
 let urls = [...];
 let controller = new AbortController();
 
-let ourJob = new Promise((resolve, reject) => { // our task
+let ourJob = new Promise((resolve, reject) => { // 자체 작업
   ...
   controller.signal.addEventListener('abort', reject);
 });
 
-let fetchJobs = urls.map(url => fetch(url, { // fetches
+let fetchJobs = urls.map(url => fetch(url, { // fetch 작업들
   signal: controller.signal
 }));
 
-// Wait for fetches and our task in parallel
+// fetch 작업과 자체 작업을 병렬로 기다립니다.
 let results = await Promise.all([...fetchJobs, ourJob]);
 
-// if controller.abort() is called from anywhere,
-// it aborts all fetches and ourJob
+// 어디서든 controller.abort()가 호출되면
+// 모든 fetch와 ourJob이 중단됩니다.
 ```
 
-## Summary
+## 요약
 
-<<<<<<< HEAD
-- `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`.
-=======
-- `AbortController` is a simple object that generates an `abort` event on its `signal` property when the `abort()` method is called (and also sets `signal.aborted` to `true`).
-- `fetch` integrates with it: we pass the `signal` property as the option, and then `fetch` listens to it, so it's possible to abort the `fetch`.
->>>>>>> upstream/master
-- 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`는 `abort()` 메서드가 호출되면 `signal` 프로퍼티에서 `abort` 이벤트를 발생시키는 단순한 객체입니다. 이때 `signal.aborted`도 `true`로 설정됩니다.
+- `fetch`는 `AbortController`와 통합되어 있습니다. `signal` 프로퍼티를 옵션으로 넘기면 `fetch`가 이를 감지하므로 `fetch`를 중단할 수 있습니다.
+- `AbortController`는 일반 코드에서도 사용할 수 있습니다. `abort()` 호출과 `abort` 이벤트 감지로 이어지는 상호작용은 단순하고 범용적입니다. `fetch` 없이도 사용할 수 있습니다.