비동기와 API 호출: fetch, Promise, async/await

서버에서 데이터를 받아 오는 동안에도 페이지가 멈추지 않게 하는 비동기 프로그래밍을 익혀요. 한 줄로 일하는 자바스크립트가 기다림을 맡겨 두는 원리, Promise와 async/await, fetch로 API를 부르고 데이터를 보내는 법을 직접 만든 실습 서버로 확인해요. 404를 실패로 알아채기, 시간 초과와 재시도, 빠르게 치는 검색창에서 생기는 응답 순서 경쟁, 다른 출처의 API를 막는 CORS, 로딩과 오류를 보여 주는 화면, 비밀 키를 브라우저에 두면 안 되는 이유까지 다뤄요.

중급강의 4 / 6약 22분

앞 강의의 코드는 모두 그 자리에서 바로 끝났어요. 하지만 서버에서 데이터를 받아 오는 일은 0.1초가 걸릴 수도, 10초가 걸릴 수도 있어요. 그동안 페이지가 얼어붙어서 스크롤도 버튼도 안 된다면 쓸 수가 없겠죠. 그래서 자바스크립트는 기다리는 일을 맡겨 두고 다른 일을 하다가, 끝나면 이어서 처리하는 방식으로 일해요. 이걸 비동기라고 해요.

실습 준비: 작은 API 서버

이 강의의 예제는 아래 파이썬 서버에 요청을 보내요. 네트워크 트랙에서 만든 서버와 같은 방식이에요. api_server.py로 저장하고 터미널에서 python api_server.py로 켠 다음, 브라우저로 http://127.0.0.1:8000/을 열고 F12를 눌러 콘솔에서 따라 해요.

# api_server.py
import json
import threading
import time
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from urllib.parse import urlsplit, parse_qs

PAGE = """<!DOCTYPE html>
<html lang="ko"><head><meta charset="utf-8"><title>API 실습</title></head>
<body><h1>API 실습</h1><p>F12를 눌러 콘솔에서 따라 해요.</p></body></html>"""
USERS = {1: {"id": 1, "name": "민지", "city": "서울"}, 2: {"id": 2, "name": "준호", "city": "부산"}}
todos = []
flaky_calls = 0


class Handler(BaseHTTPRequestHandler):
    def log_message(self, *args):
        pass

    def send(self, status, body, content_type="application/json; charset=utf-8", extra=()):
        data = body.encode() if isinstance(body, str) else json.dumps(body, ensure_ascii=False).encode()
        try:
            self.send_response(status)
            self.send_header("Content-Type", content_type)
            self.send_header("Content-Length", str(len(data)))
            for name, value in extra:
                self.send_header(name, value)
            self.end_headers()
            self.wfile.write(data)
        except ConnectionError:
            pass                                    # 브라우저가 기다리다 포기하고 끊은 경우

    def do_GET(self):
        global flaky_calls
        url = urlsplit(self.path)
        query = parse_qs(url.query)
        if url.path == "/":
            self.send(200, PAGE, "text/html; charset=utf-8")
        elif url.path.startswith(("/api/users/", "/api/open/users/")):
            user = USERS.get(int(url.path.rsplit("/", 1)[1]))
            extra = [("Access-Control-Allow-Origin", "http://127.0.0.1:8000")] if "/open/" in url.path else []
            if user:
                self.send(200, user, extra=extra)
            else:
                self.send(404, {"error": "없는 사용자예요"}, extra=extra)
        elif url.path == "/api/slow":
            time.sleep(int(query.get("ms", ["1000"])[0]) / 1000)
            self.send(200, {"message": "늦었지만 도착"})
        elif url.path == "/api/flaky":
            flaky_calls += 1
            if flaky_calls % 3:                     # 세 번 중 두 번은 실패해요
                self.send(503, {"error": "잠시 후 다시 시도하세요"})
            else:
                self.send(200, {"message": "이제 괜찮아요"})
        elif url.path == "/api/search":
            word = query.get("q", [""])[0]
            time.sleep(max(50, 400 - 100 * len(word)) / 1000)   # 짧은 검색어일수록 오래 걸리게
            self.send(200, {"result": f"'{word}' 검색 결과"})
        else:
            self.send(404, {"error": "없는 주소예요"})

    def do_POST(self):
        if self.path != "/api/todos":
            return self.send(404, {"error": "없는 주소예요"})
        body = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
        todo = {"id": len(todos) + 1, "text": body["text"], "done": False}
        todos.append(todo)
        self.send(201, todo)


for port in (8000, 8001):                           # 8001번은 '다른 출처' 실험용
    server = ThreadingHTTPServer(("127.0.0.1", port), Handler)
    threading.Thread(target=server.serve_forever, daemon=True).start()
print("http://127.0.0.1:8000/ 을 브라우저로 여세요. 멈추려면 Ctrl+C")
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    pass

일부러 느린 주소(/api/slow), 세 번 중 두 번은 실패하는 주소(/api/flaky), 짧은 검색어일수록 늦게 답하는 검색(/api/search)을 넣어 두었어요. 실제 서비스에서 만나는 골칫거리를 재현하려고요. 콘솔에서는 맨 위에서 바로 await를 쓸 수 있어서 예제를 그대로 붙여 넣으면 돼요. 앞 강의처럼 순서대로 붙여 넣어요. 페이지가 열리지 않고 연결이 끊긴다면, 네트워크 문제 진단 강의의 사례처럼 광고 차단이나 보안 프로그램이 내 컴퓨터 안의 통신을 검사하고 있을 수 있어요. 잠시 끄거나 127.0.0.1을 예외로 두고 다시 해 보세요.

한 줄로 일하는 자바스크립트

자바스크립트는 한 번에 한 가지 일만 해요. 그래서 시간이 걸리는 일은 브라우저에게 맡겨 두고(타이머, 네트워크 요청), 끝나면 할 일을 대기열에 넣어 차례를 기다리게 해요. 순서를 맞혀 보세요.

console.log("1. 시작");
setTimeout(() => console.log("4. 타이머(0ms)"), 0);
Promise.resolve().then(() => console.log("3. 약속(Promise)"));
console.log("2. 끝");
1. 시작
2. 끝
3. 약속(Promise)
4. 타이머(0ms)

0ms 타이머인데도 맨 마지막이에요. 순서는 이렇게 정해져요.

  1. 지금 실행 중인 코드를 끝까지 실행해요(1, 2).
  2. 끝난 약속(Promise)의 뒷일을 모두 처리해요(3). 이 대기열은 우선순위가 높아요.
  3. 그다음에야 타이머나 클릭 같은 다음 일을 하나 꺼내요(4).

이 구조 때문에 오래 걸리는 계산을 그냥 돌리면 페이지 전체가 멈춰요. 3초짜리 반복문이 도는 동안에는 클릭도, 스크롤도, 화면 그리기도 모두 줄을 서서 기다리거든요. 반대로 네트워크를 기다리는 동안에는 자바스크립트가 아무것도 붙잡고 있지 않아서 페이지가 멀쩡히 움직여요.

약속(Promise)과 async/await

Promise는 "나중에 값을 주겠다"는 약속 증서예요. 처음에는 기다리는 중(pending)이고, 나중에 성공(fulfilled)하면 값을, 실패(rejected)하면 오류를 내놓아요. await를 붙이면 약속이 끝날 때까지 이 함수만 멈춰서 기다려요. 페이지 전체가 멈추는 게 아니에요.

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

function download(name, ms, fail = false) {
  return new Promise((resolve, reject) => {
    setTimeout(() => (fail ? reject(new Error(`${name} 실패`)) : resolve(`${name} 완료`)), ms);
  });
}

const round100 = (ms) => Math.round(ms / 100) * 100;
let t = performance.now();
const photo = await download("사진", 300);
const music = await download("음악", 200);
console.log(photo, music, `차례로 기다리면 약 ${round100(performance.now() - t)}ms`);

t = performance.now();
const both = await Promise.all([download("사진", 300), download("음악", 200)]);
console.log(both.join(" "), `한꺼번에 기다리면 약 ${round100(performance.now() - t)}ms`);

try {
  await download("영상", 100, true);
} catch (err) {
  console.log("잡았어요:", err.message);
}
const settled = await Promise.allSettled([download("A", 50), download("B", 80, true)]);
console.log(settled.map((r) => (r.status === "fulfilled" ? r.value : `거절(${r.reason.message})`)).join(", "));
사진 완료 음악 완료 차례로 기다리면 약 500ms
사진 완료 음악 완료 한꺼번에 기다리면 약 300ms
잡았어요: 영상 실패
A 완료, 거절(B 실패)
  • 차례로와 한꺼번에의 차이: 서로 상관없는 두 일을 하나씩 await하면 300 + 200으로 500ms가 걸려요. Promise.all로 함께 출발시키면 가장 긴 300ms면 끝나요. 페이지에 필요한 데이터 여러 개를 받을 때 이 차이가 그대로 로딩 시간이 돼요.
  • 실패는 try와 catch로 잡아요. 파이썬의 try와 except와 같아요.
  • Promise.all은 하나만 실패해도 전체가 실패해요. 일부가 실패해도 나머지 결과를 쓰고 싶다면 Promise.allSettled로 하나하나의 결과를 받아요.

예전에는 "끝나면 이 함수를 불러 줘"라고 함수를 넘기는 콜백 방식만 있어서, 기다림이 이어질수록 코드가 오른쪽으로 끝없이 들여 쓰였어요. async와 await는 같은 일을 위에서 아래로 읽히게 써 주는 문법이에요.

fetch로 API 부르기

API는 프로그램끼리 데이터를 주고받는 창구예요. 웹에서는 보통 HTTP로 요청하고 JSON으로 답을 받아요. 브라우저에서는 fetch로 불러요.

async function getJSON(url) {
  const res = await fetch(url);
  if (!res.ok) throw new Error(`HTTP ${res.status}`);   // fetch는 404에도 실패하지 않아요
  return res.json();
}

const first = await getJSON("/api/users/1");
console.log(first.name, first.city);
try {
  await getJSON("/api/users/999");
} catch (err) {
  console.log("실패:", err.message);
}
const raw = await fetch("/api/users/999");
console.log("fetch 자체는 성공:", raw.ok, raw.status, (await raw.json()).error);
민지 서울
실패: HTTP 404
fetch 자체는 성공: false 404 없는 사용자예요

마지막 줄이 이 절의 핵심이에요. fetch는 404나 500을 받아도 실패하지 않아요. 서버가 답을 했으니 통신은 성공한 거예요. fetch가 실패하는 건 서버에 닿지도 못했을 때(네트워크 끊김, 주소 오류, 다음에 볼 CORS 차단)뿐이에요. 그래서 res.ok(상태 코드가 200번대인지)를 꼭 확인하고, 아니면 직접 오류를 던져야 해요. 응답 본문을 읽는 res.json()도 시간이 걸릴 수 있어서 await를 붙여요.

데이터 보내기와 기다림의 한계

데이터를 보낼 때는 메서드, 헤더, 본문을 함께 적어요. HTTP 강의에서 손으로 만들어 본 요청 그대로예요.

const created = await fetch("/api/todos", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ text: "API 강의 읽기" }),
});
console.log(created.status, JSON.stringify(await created.json()));

try {
  await fetch("/api/slow?ms=3000", { signal: AbortSignal.timeout(500) });
} catch (err) {
  console.log("0.5초 기다리고 포기:", err.name);
}
201 {"id":1,"text":"API 강의 읽기","done":false}
0.5초 기다리고 포기: TimeoutError
  • 서버가 "새로 만들었어요"라는 뜻의 201과 함께 만든 항목을 돌려줬어요.
  • fetch에는 기본 제한 시간이 없어요. 파이썬의 requests처럼, 정해 두지 않으면 응답 없는 서버를 하염없이 기다려요. AbortSignal.timeout(500)을 주면 0.5초 뒤에 포기하고 TimeoutError를 내요.

실패를 다루는 법: 다시 시도

서버가 잠깐 바쁘거나(503), 너무 자주 요청한다고 하거나(429), 네트워크가 순간 끊기는 일은 흔해요. 이럴 땐 잠시 쉬었다가 다시 시도하면 대개 성공해요. 쉬는 시간을 점점 늘리는 게 요령이에요.

async function fetchWithRetry(url, tries = 4) {
  for (let attempt = 1; attempt <= tries; attempt++) {
    let reason;
    try {
      const res = await fetch(url);
      if (res.ok) return { data: await res.json(), attempt };
      if (res.status < 500 && res.status !== 429) throw new Error(`HTTP ${res.status}`);  // 다시 해도 소용없는 오류
      reason = res.status;
    } catch (err) {
      if (!(err instanceof TypeError)) throw err;          // 네트워크가 끊기면 fetch는 TypeError를 내요
      reason = "네트워크 오류";
    }
    const wait = 100 * 2 ** (attempt - 1);                 // 100, 200, 400ms로 점점 길게
    console.log(`${attempt}번째 시도: ${reason}, ${wait}ms 쉬고 다시`);
    await sleep(wait);
  }
  throw new Error("끝내 실패했어요");
}

const result = await fetchWithRetry("/api/flaky");
console.log(`${result.attempt}번째에 성공:`, result.data.message);
1번째 시도: 503, 100ms 쉬고 다시
2번째 시도: 503, 200ms 쉬고 다시
3번째에 성공: 이제 괜찮아요
  • 다시 해 볼 만한 오류만 다시 해요. 5xx와 429, 그리고 네트워크가 순간 끊겨 fetch 자체가 실패한 경우(TypeError)는 시간이 지나면 나아질 수 있지만, 404나 400은 몇 번을 보내도 똑같아요. 그래서 HTTP 404로 직접 던진 오류는 catch에서 다시 던져 바로 멈추게 했어요.
  • 쉬는 시간을 두 배씩 늘리는 걸 지수 백오프라고 해요. 모두가 같은 순간에 다시 몰려들지 않도록, 실제로는 쉬는 시간에 무작위 값을 조금 섞기도 해요. 서버가 Retry-After 헤더로 쉴 시간을 알려 주면 그 시간을 따라요.
  • POST는 함부로 다시 보내지 않아요. HTTP 강의에서 본 멱등성 문제예요. 응답만 못 받았을 뿐 주문이 이미 들어갔을 수도 있어요.

빨리 치는 사람: 응답 순서 경쟁

검색창에 글자를 칠 때마다 요청을 보내면 문제가 생겨요. 요청은 보낸 순서대로 오지 않거든요. 실습 서버는 짧은 검색어일수록 늦게 답하게 해 두었어요.

const screen = { text: "" };                          // 화면에 보이는 검색 결과라고 생각해요
const typed = ["서", "서울", "서울역"];                  // 사용자가 빠르게 친 순서

async function naiveSearch(q) {
  const res = await fetch(`/api/search?q=${encodeURIComponent(q)}`);
  screen.text = (await res.json()).result;
}
await Promise.all(typed.map((q, i) => sleep(i * 10).then(() => naiveSearch(q))));
console.log("그냥 보내면:", screen.text);

let controller = null;
async function search(q) {
  controller?.abort();                                 // 앞의 요청은 취소해요
  controller = new AbortController();
  try {
    const res = await fetch(`/api/search?q=${encodeURIComponent(q)}`, { signal: controller.signal });
    screen.text = (await res.json()).result;
  } catch (err) {
    if (err.name !== "AbortError") throw err;
  }
}
await Promise.all(typed.map((q, i) => sleep(i * 10).then(() => search(q))));
console.log("앞 요청을 취소하면:", screen.text);
그냥 보내면: '서' 검색 결과
앞 요청을 취소하면: '서울역' 검색 결과

사용자는 "서울역"까지 쳤는데, 화면에는 가장 늦게 도착한 "서"의 결과가 남았어요. 이런 버그를 경쟁 상태(race condition)라고 해요. 내 컴퓨터에서는 응답이 늘 빨라서 안 보이다가, 실제 사용자의 느린 회선에서만 나타나서 더 고약해요. AbortController로 새 요청을 보낼 때 앞 요청을 취소하면 마지막 검색어의 결과만 남아요.

애초에 요청을 덜 보내는 방법도 함께 써요. 글자를 칠 때마다가 아니라 치기를 잠깐 멈췄을 때 한 번만 보내는 거예요. 이걸 디바운스라고 해요.

function debounce(fn, ms) {
  let timer;
  return (...args) => {
    clearTimeout(timer);
    timer = setTimeout(() => fn(...args), ms);
  };
}

const sent = [];
const sendQuery = debounce((q) => sent.push(q), 300);
for (const q of typed) sendQuery(q);                 // 빠르게 세 번 쳐도
await sleep(400);
console.log("실제로 보낸 검색어:", sent.join(", "));
실제로 보낸 검색어: 서울역

세 번 쳤지만 요청은 한 번만 갔어요. 서버 부담도 줄고, 경쟁 상태가 생길 틈도 줄어요.

다른 출처의 API: CORS

이번에는 같은 서버의 8001번 포트에 요청해 볼게요. 데이터는 똑같아요.

try {
  const res = await fetch("http://127.0.0.1:8001/api/users/1");
  console.log("읽음:", (await res.json()).name);
} catch (err) {
  console.log("막힘:", err.name, err.message);
}
const allowed = await fetch("http://127.0.0.1:8001/api/open/users/2");
console.log("허락한 곳에서는:", (await allowed.json()).name);
막힘: TypeError Failed to fetch
허락한 곳에서는: 준호

브라우저는 스킴, 호스트, 포트가 모두 같아야 같은 출처로 봐요. 지금 페이지는 http://127.0.0.1:8000이라 8001번은 다른 출처예요. 다른 출처의 응답은 그 서버가 "이 출처는 읽어도 된다"고 Access-Control-Allow-Origin 헤더로 허락했을 때만 페이지가 읽을 수 있어요. 이 규칙이 CORS예요. 실습 서버는 /api/open/ 주소에만 그 헤더를 붙였어요. 콘솔에는 빨간 글씨로 "blocked by CORS policy"라는 자세한 이유가 함께 떠요. 자바스크립트가 받는 오류는 일부러 "Failed to fetch"로만 뭉뚱그려져 있어서, 원인은 콘솔 메시지에서 확인해요.

CORS에서 자주 오해하는 점이 있어요.

  • 요청은 서버에 갔어요. 서버는 응답도 했어요. 브라우저가 그 응답을 페이지에 넘겨주지 않았을 뿐이에요.
  • CORS는 서버를 지키는 장치가 아니에요. curl이나 파이썬은 CORS와 상관없이 어떤 API든 불러요. CORS는 내가 방문한 수상한 사이트가 내 브라우저의 로그인 정보로 은행 사이트 같은 다른 출처의 데이터를 몰래 읽어 가지 못하게, 사용자를 지키는 장치예요.
  • JSON을 POST하거나 특별한 헤더를 붙인 요청은, 브라우저가 먼저 OPTIONS 메서드로 "이런 요청을 보내도 되나요?"라고 묻는 사전 요청을 보내요. 서버가 이 질문에도 허락으로 답해야 해요.
  • 해결은 서버에서 허락 헤더를 설정하거나, 같은 출처의 내 서버가 대신 불러 주게 하는 거예요. CORS를 끄는 브라우저 확장으로는 내 컴퓨터에서만 될 뿐, 사용자에게는 여전히 안 돼요.

화면에 그리기: 기다림과 실패도 화면이에요

사용자는 콘솔을 보지 않아요. 데이터를 기다리는 동안과 실패했을 때도 화면에 알려 줘야 해요.

const statusLine = document.createElement("p");
document.body.append(statusLine);

async function showUser(id) {
  statusLine.textContent = "불러오는 중이에요";
  try {
    const user = await getJSON(`/api/users/${id}`);
    statusLine.textContent = `${user.name}님 (${user.city})`;
  } catch (err) {
    statusLine.textContent = `불러오지 못했어요 (${err.message}). 잠시 후 다시 시도해 주세요.`;
  }
}

const seen = [];
const loading = showUser(2);
seen.push(statusLine.textContent);                    // 기다리는 동안 보이는 글
await loading;
seen.push(statusLine.textContent);
await showUser(999);
seen.push(statusLine.textContent);
console.log(seen.join("\n"));
불러오는 중이에요
준호님 (부산)
불러오지 못했어요 (HTTP 404). 잠시 후 다시 시도해 주세요.

데이터를 보여 주는 화면에는 늘 네 가지 상태가 있다고 생각하면 빠뜨리지 않아요. 불러오는 중, 성공, 실패, 비어 있음이에요. 검색 결과가 0개일 때 아무것도 안 보이면 사용자는 고장 난 줄 알아요. "결과가 없어요" 한 줄이 필요해요. 요청이 진행되는 동안 버튼을 잠시 누르지 못하게(button.disabled = true) 하면 같은 요청이 두 번 가는 것도 막을 수 있어요.

비밀 키는 브라우저에 두지 않아요

브라우저로 보낸 자바스크립트는 누구나 개발자 도구의 Sources 탭에서 열어 볼 수 있어요. 돈이 드는 API의 키를 코드에 넣으면 그대로 공개되고, 누군가 그 키로 내 사용량을 다 써 버릴 수 있어요. 키가 필요한 API는 내 서버(또는 서버리스 함수)가 대신 부르게 하고, 브라우저는 내 서버만 불러요. 키는 서버의 환경 변수에만 두고, 내 서버에서도 요청 횟수를 제한해 두면 더 안전해요.

실습

  1. 첫 예제에 queueMicrotask(() => console.log("마이크로"))와 setTimeout 하나를 더 넣고, 실행하기 전에 순서를 맞혀 보세요.
  2. Promise.all 예제의 download("음악", 200)을 실패하게 바꾸면 어떻게 되나요? Promise.allSettled와 비교해 보세요.
  3. 실습 서버가 503을 보낼 때 Retry-After: 1 헤더를 붙이게 고치고, fetchWithRetry가 그 값을 읽어 쉬도록 바꿔 보세요.
  4. 서버의 /api/search에 print(word)를 넣고, 디바운스와 취소를 함께 쓴 검색창에서 빠르게 칠 때 요청이 몇 번 가는지 세어 보세요.
  5. 서버에서 Access-Control-Allow-Origin을 지우고 /api/open/ 요청을 다시 해 보세요. 콘솔의 빨간 메시지에는 뭐라고 나오나요?
  6. 개발자 도구 Network 탭의 속도 제한(Throttling)을 느린 회선으로 바꾸고 showUser(1)을 실행해, 로딩 문구가 보이는 시간을 확인해 보세요.

자주 하는 실수

  • res.ok를 확인하지 않는다. 오류 페이지를 JSON으로 읽으려다 엉뚱한 곳에서 터져요.
  • await를 빼먹는다. 값 대신 Promise {<pending>}가 찍히거나 [object Promise]가 화면에 나와요.
  • forEach 안에서 await한다. forEach는 기다려 주지 않아요. 차례로 하려면 for...of, 한꺼번에 하려면 Promise.all을 써요.
  • 서로 상관없는 요청을 하나씩 기다린다. Promise.all로 함께 보내요.
  • 제한 시간을 두지 않는다. 응답 없는 서버 하나에 화면이 영원히 "불러오는 중"으로 남아요.
  • 아무 오류나 다시 시도한다. 4xx는 다시 해도 같고, POST는 중복될 수 있어요.
  • CORS를 확장 프로그램으로 끄고 해결했다고 생각한다. 서버에서 허락해야 모든 사용자에게 돼요.
  • API 키를 프런트엔드 코드에 넣는다. 공개된 거나 마찬가지예요.

점검 문제

  1. 0ms 타이머가 끝난 약속(Promise)의 뒷일보다 늦게 실행되는 이유는?
  2. 오래 걸리는 계산을 그냥 돌리면 페이지가 멈추는데, 네트워크를 기다릴 때는 멈추지 않는 이유는?
  3. 300ms와 200ms가 걸리는 두 요청을 차례로 기다리면 약 몇 ms, Promise.all로 기다리면 약 몇 ms가 걸리나요?
  4. fetch가 404 응답에 실패하지 않는 이유와, 그래서 꼭 해야 하는 일은?
  5. 다시 시도해 볼 만한 오류와 그렇지 않은 오류의 예는?
  6. 검색창에서 응답 순서 경쟁이 생기는 이유와, 막는 방법 두 가지는?
  7. CORS에 막혔을 때 요청은 서버에 갔나요? CORS는 누구를 지키나요?
  8. 돈이 드는 API의 키를 브라우저 코드에 넣으면 안 되는 이유와 대안은?

정답

  1. 지금 코드가 끝나면 끝난 약속의 뒷일을 먼저 모두 처리하고, 타이머 같은 다음 일은 그 뒤에 하나씩 꺼내기 때문이에요.
  2. 계산은 자바스크립트가 직접 붙잡고 하는 일이라 그동안 다른 일을 못 하지만, 네트워크 기다림은 브라우저에게 맡겨 두고 끝나면 대기열로 돌아오기 때문이에요.
  3. 차례로 기다리면 약 500ms, Promise.all로 함께 기다리면 약 300ms예요.
  4. 서버가 답을 했으니 통신 자체는 성공한 것으로 보기 때문이에요. 그래서 res.ok나 res.status를 확인해서 실패를 직접 처리해야 해요.
  5. 503, 429, 일시적인 네트워크 끊김은 다시 해 볼 만하고, 404, 400, 401처럼 요청 자체가 잘못된 오류는 다시 해도 같아요.
  6. 요청은 보낸 순서대로 돌아오지 않아서, 늦게 온 앞 검색어의 결과가 마지막 결과를 덮어쓰기 때문이에요. 새 요청을 보낼 때 앞 요청을 취소하거나(AbortController), 치기를 멈췄을 때만 보내요(디바운스).
  7. 네, 요청은 서버에 갔고 서버도 응답했어요. 브라우저가 응답을 페이지에 넘겨주지 않은 거예요. CORS는 서버가 아니라 사용자를, 정확히는 내 브라우저의 로그인 정보가 다른 사이트에 악용되지 않게 지켜요.
  8. 브라우저로 보낸 코드는 누구나 열어 볼 수 있어서 키가 공개되기 때문이에요. 내 서버나 서버리스 함수가 키를 갖고 대신 부르게 하고, 브라우저는 내 서버만 불러요.

다음 강의

이제 데이터를 받아 와서 화면에 그릴 수 있어요. 그런데 화면을 브라우저에서 그릴지, 서버에서 미리 그려 보낼지, 아예 배포할 때 만들어 둘지에 따라 속도와 검색 노출이 크게 달라져요. 다음 강의에서는 React 같은 프레임워크가 하는 일과 CSR, SSR, SSG라는 세 가지 렌더링 방식을 비교해요.