콘텐츠 대표 이미지 - JavaScript async/await: 비동기 코드의 동기적 표현

JavaScript async/await: 비동기 코드의 동기적 표현

안녕하세요 여러분! 오늘은 자바스크립트의 꿀기능 중 하나인 async/await에 대해 함께 알아볼게요! 🚀 자바스크립트 개발하다 보면 비동기 처리 때문에 머리 아픈 경험 다들 있으시죠? ㅋㅋㅋ 콜백 지옥에 빠져본 분들 손! 🙋‍♀️

비동기 코드를 동기적으로 표현할 수 있게 해주는 마법같은 async/await! 이거 제대로 알면 개발 생산성이 진짜 미쳐버리게 올라가요. 실제로 재능넷에서 프로그래밍 재능을 공유하는 개발자분들도 이 기능 덕분에 코드 가독성이 엄청 좋아졌다고 하더라구요. 😎

이번 글에서는 비동기 프로그래밍의 기초부터 async/await의 모든 것까지 완전 정복해볼 거예요! 어렵게 느껴질 수 있지만 차근차근 따라오시면 "아 이거였어?" 하는 순간이 올 거예요! 그럼 시작해볼까요? 💪

1. 비동기 프로그래밍이 뭔데? 🤔

자바스크립트는 싱글 스레드 언어예요. 이게 무슨 말이냐면, 한 번에 하나의 작업만 처리할 수 있다는 거죠. 근데 웹사이트에서는 여러 작업이 동시에 일어나야 하잖아요? 데이터도 가져오고, 애니메이션도 돌리고, 사용자 입력도 받고... 이걸 어떻게 하냐구요? 바로 비동기 프로그래밍 덕분이에요!

비동기 프로그래밍은 코드가 순차적으로 실행되지 않고, 특정 작업이 완료될 때까지 기다리지 않고 다음 코드를 실행하는 방식이에요. 예를 들어볼까요?

console.log("안녕하세요!");
setTimeout(() => {
  console.log("3초 후에 실행됩니다.");
}, 3000);
console.log("반갑습니다!");

이 코드의 실행 결과는 어떻게 될까요?

안녕하세요!
반갑습니다!
3초 후에 실행됩니다.

ㅋㅋㅋ 순서가 이상하죠? "안녕하세요" 다음에 "반갑습니다"가 먼저 출력되고, 3초 후에야 "3초 후에 실행됩니다"가 출력돼요. 이게 바로 비동기 프로그래밍의 특징이에요! 🕒

자바스크립트에서 비동기 작업을 처리하는 방법은 크게 세 가지가 있어요:

  1. 콜백 함수 (Callback Functions)
  2. 프로미스 (Promises)
  3. async/await

이 중에서 오늘의 주인공은 바로 async/await! 근데 이걸 제대로 이해하려면 콜백과 프로미스도 알아야 해요. 그럼 하나씩 살펴볼게요! 😉

2. 콜백 함수: 비동기의 시작 📞

콜백 함수는 다른 함수에 인자로 전달되는 함수예요. 비동기 작업이 완료된 후에 실행되도록 설계되었죠. 가장 기본적인 비동기 처리 방식이에요.

function fetchData(callback) {
  // 데이터를 가져오는 비동기 작업을 시뮬레이션
  setTimeout(() => {
    const data = { name: "재능넷", users: 1000 };
    callback(data);
  }, 2000);
}

fetchData((data) => {
  console.log("데이터 받았다!", data);
  // 결과: 2초 후 "데이터 받았다! {name: "재능넷", users: 1000}" 출력
});

간단해 보이죠? 근데 비동기 작업이 여러 개 중첩되면...? 😱

fetchData((data) => {
  console.log("첫 번째 데이터:", data);
  fetchAnotherData(data, (newData) => {
    console.log("두 번째 데이터:", newData);
    fetchYetAnotherData(newData, (finalData) => {
      console.log("세 번째 데이터:", finalData);
      // 더 많은 중첩된 콜백들...
    });
  });
});

헐... 이게 바로 악명 높은 콜백 지옥(Callback Hell)이에요! 코드가 오른쪽으로 계속 들여쓰기 되면서 피라미드 모양이 되죠. 이런 코드는 읽기도 어렵고 디버깅하기도 너무 힘들어요. ㅠㅠ

이런 문제를 해결하기 위해 등장한 게 바로 프로미스(Promise)예요! 다음 섹션에서 알아볼게요~ 🏃‍♂️

3. 프로미스: 콜백 지옥 탈출하기 🏃‍♀️

프로미스는 비동기 작업의 최종 완료(또는 실패)와 그 결과값을 나타내는 객체예요. 쉽게 말하면 "나 이거 나중에 줄게~"라는 약속(promise)이죠! ㅋㅋㅋ

프로미스는 다음 세 가지 상태 중 하나를 가져요:

  1. 대기(Pending): 초기 상태, 이행되거나 거부되지 않은 상태
  2. 이행(Fulfilled): 연산이 성공적으로 완료됨
  3. 거부(Rejected): 연산이 실패함

프로미스를 사용하면 아까의 콜백 지옥을 이렇게 바꿀 수 있어요:

function fetchData() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      const data = { name: "재능넷", users: 1000 };
      resolve(data); // 성공 시 resolve 호출
      // 실패 시에는 reject(new Error("에러 메시지")) 호출
    }, 2000);
  });
}

fetchData()
  .then(data => {
    console.log("첫 번째 데이터:", data);
    return fetchAnotherData(data);
  })
  .then(newData => {
    console.log("두 번째 데이터:", newData);
    return fetchYetAnotherData(newData);
  })
  .then(finalData => {
    console.log("세 번째 데이터:", finalData);
  })
  .catch(error => {
    console.error("에러 발생:", error);
  });

오! 훨씬 깔끔해졌죠? 🎉 .then() 메서드를 체이닝해서 순차적으로 비동기 작업을 처리할 수 있고, .catch()로 에러 처리도 한 번에 할 수 있어요.

프로미스의 주요 메서드들을 알아볼까요?

  1. Promise.then(): 프로미스가 이행되었을 때 실행할 콜백 등록
  2. Promise.catch(): 프로미스가 거부되었을 때 실행할 콜백 등록
  3. Promise.finally(): 프로미스의 이행/거부 여부와 상관없이 실행할 콜백 등록
  4. Promise.all(): 여러 프로미스가 모두 이행될 때까지 기다림
  5. Promise.race(): 여러 프로미스 중 가장 먼저 이행/거부되는 것을 기다림

특히 Promise.all()은 여러 비동기 작업을 병렬로 처리할 때 정말 유용해요!

Promise.all([fetchUser(), fetchPosts(), fetchComments()])
  .then(([user, posts, comments]) => {
    console.log("모든 데이터 로딩 완료!", user, posts, comments);
  })
  .catch(error => {
    console.error("하나라도 실패하면 여기로 옴:", error);
  });

프로미스 진짜 좋죠? 근데... 여전히 좀 복잡해 보이지 않나요? 특히 여러 개의 .then()이 체이닝되면 코드 흐름을 따라가기가 쉽지 않아요. 이럴 때 필요한 게 바로 오늘의 주인공 async/await입니다! 🌟

콜백 지옥 callback( callback( callback( callback( ) ) ) ) 프로미스 promise .then() .then() .then() .catch() Async/Await async function() { try { const a = await A(); const b = await B(); const c = await C(); } catch (err) { // 에러 처리 } } 발전 발전

4. async/await: 비동기의 혁명 ✨

드디어 오늘의 주인공 등장이요! async/await는 ES2017(ES8)에서 도입된 기능으로, 프로미스 기반 비동기 코드를 마치 동기 코드처럼 작성할 수 있게 해줘요. 진짜 혁명적인 기능이죠! 🚀

async/await의 기본 구문은 이렇게 생겼어요:

async function myFunction() {
  try {
    const result = await someAsyncOperation();
    console.log(result);
  } catch (error) {
    console.error(error);
  }
}

여기서 두 가지 키워드를 사용해요:

  1. async: 함수 앞에 붙여서 이 함수가 항상 프로미스를 반환하도록 만듦
  2. await: 프로미스가 처리될 때까지 함수 실행을 일시 중지함 (async 함수 내에서만 사용 가능)

이제 아까의 프로미스 예제를 async/await로 바꿔볼게요:

async function fetchAllData() {
  try {
    const data = await fetchData();
    console.log("첫 번째 데이터:", data);
    
    const newData = await fetchAnotherData(data);
    console.log("두 번째 데이터:", newData);
    
    const finalData = await fetchYetAnotherData(newData);
    console.log("세 번째 데이터:", finalData);
    
    return finalData; // 이 값은 프로미스로 감싸져서 반환됨
  } catch (error) {
    console.error("에러 발생:", error);
    throw error; // 에러를 다시 던져서 이 함수를 호출한 쪽에서도 처리할 수 있게 함
  }
}

// 함수 호출
fetchAllData()
  .then(result => console.log("최종 결과:", result))
  .catch(error => console.error("최종 에러 처리:", error));

우와! 이제 코드가 마치 동기 코드처럼 위에서 아래로 읽히죠? try/catch로 에러 처리도 깔끔하게 할 수 있고요. 이게 바로 async/await의 매력이에요! 😍

근데 잠깐, await는 항상 순차적으로 실행될까요? 만약 여러 비동기 작업이 서로 의존성이 없다면, 병렬로 실행하는 게 더 효율적일 수 있어요. 이럴 때는 Promise.all()과 await를 함께 사용하면 돼요!

async function fetchAllDataParallel() {
  try {
    // 세 개의 비동기 작업을 동시에 시작하고 모두 완료될 때까지 기다림
    const [user, posts, comments] = await Promise.all([
      fetchUser(),
      fetchPosts(),
      fetchComments()
    ]);
    
    console.log("사용자:", user);
    console.log("포스트:", posts);
    console.log("댓글:", comments);
    
    return { user, posts, comments };
  } catch (error) {
    console.error("에러 발생:", error);
    throw error;
  }
}

이렇게 하면 세 개의 API 호출이 병렬로 실행되고, 모두 완료될 때까지 기다렸다가 결과를 한 번에 받을 수 있어요. 진짜 개꿀팁! 🍯

5. async/await 심화: 알아두면 좋은 팁들 💡

이제 async/await의 기본은 알았으니, 더 깊이 들어가볼까요? 실무에서 정말 유용한 팁들을 알려드릴게요!

5.1 async 함수는 항상 프로미스를 반환해요

async function getValue() {
  return 42; // 자동으로 Promise.resolve(42)로 변환됨
}

getValue().then(value => console.log(value)); // 42

심지어 에러를 던져도 프로미스로 감싸져요:

async function failingFunction() {
  throw new Error("이런!");
}

failingFunction()
  .then(value => console.log(value)) // 실행 안 됨
  .catch(error => console.error(error)); // Error: 이런!

5.2 await는 프로미스가 아닌 값에도 사용할 수 있어요

async function example() {
  const value = await 42; // Promise.resolve(42)와 동일하게 작동
  console.log(value); // 42
}

이렇게 하면 코드가 더 일관성 있게 보일 수 있어요. 하지만 실제로는 불필요한 오버헤드가 생길 수 있으니 주의하세요!

5.3 await 없이 프로미스 시작하기

여러 비동기 작업을 병렬로 실행하는 또 다른 방법은 먼저 프로미스를 시작한 다음 나중에 await 하는 거예요:

async function fetchUserAndPosts() {
  // 두 프로미스를 동시에 시작
  const userPromise = fetchUser();
  const postsPromise = fetchPosts();
  
  // 각각 완료될 때까지 기다림
  const user = await userPromise;
  const posts = await postsPromise;
  
  return { user, posts };
}

이 방법은 Promise.all()을 사용하는 것과 비슷하지만, 각 프로미스의 결과를 개별적으로 처리할 수 있어요.

5.4 루프에서 await 사용하기

배열의 각 항목에 대해 비동기 작업을 수행해야 할 때가 있죠. 이럴 때는 두 가지 방법이 있어요:

1) 순차 실행 (하나씩 기다리기):

async function processItems(items) {
  const results = [];
  
  for (const item of items) {
    // 각 항목을 처리한 후 다음으로 넘어감
    const result = await processItem(item);
    results.push(result);
  }
  
  return results;
}

2) 병렬 실행 (모두 동시에 시작하고 기다리기):

async function processItemsParallel(items) {
  // 모든 프로미스를 배열에 매핑
  const promises = items.map(item => processItem(item));
  
  // 모든 프로미스가 완료될 때까지 기다림
  const results = await Promise.all(promises);
  return results;
}

어떤 방법을 선택할지는 상황에 따라 달라요. 작업이 서로 독립적이고 순서가 중요하지 않다면 병렬 실행이 더 빠르지만, 이전 작업의 결과가 다음 작업에 필요하거나 순서가 중요하다면 순차 실행을 사용해야 해요.

5.5 await 블록 밖에서 에러 처리하기

async 함수 내부에서 try/catch를 사용하는 것 외에도, 함수 호출 시 .catch()를 사용할 수도 있어요:

async function riskyOperation() {
  // try/catch 없음
  const data = await fetchData();
  return data.processedValue;
}

// 함수 호출 시 에러 처리
riskyOperation()
  .then(result => console.log("성공:", result))
  .catch(error => console.error("실패:", error));

두 방법 모두 유효하니, 상황에 맞게 선택하세요!

6. async/await의 실제 사용 사례 🛠️

이론은 충분히 배웠으니 이제 실제 사용 사례를 몇 가지 살펴볼게요! 실무에서 자주 마주치는 상황들이에요.

6.1 API 데이터 가져오기

async function fetchUserData(userId) {
  try {
    const response = await fetch(`https://api.example.com/users/${userId}`);
    
    if (!response.ok) {
      throw new Error(`HTTP 에러! 상태: ${response.status}`);
    }
    
    const userData = await response.json();
    return userData;
  } catch (error) {
    console.error("사용자 데이터를 가져오는 중 오류 발생:", error);
    throw error;
  }
}

Fetch API와 async/await의 조합은 정말 환상적이에요! 이전에는 .then() 체인을 사용해야 했지만, 이제는 훨씬 읽기 쉬운 코드를 작성할 수 있어요.

6.2 여러 API 호출 조합하기

async function getUserWithPosts(userId) {
  try {
    // 사용자 정보와 게시물을 병렬로 가져옴
    const [user, posts] = await Promise.all([
      fetchUserData(userId),
      fetchUserPosts(userId)
    ]);
    
    // 사용자 객체에 게시물 배열 추가
    user.posts = posts;
    
    // 각 게시물에 대한 댓글을 가져옴 (순차적으로)
    for (const post of posts) {
      post.comments = await fetchPostComments(post.id);
    }
    
    return user;
  } catch (error) {
    console.error("데이터를 가져오는 중 오류 발생:", error);
    throw error;
  }
}

이 예제에서는 병렬 실행(Promise.all)과 순차 실행(for 루프 + await)을 모두 사용했어요. 사용자와 게시물은 서로 독립적이므로 병렬로 가져오고, 각 게시물의 댓글은 게시물 ID에 의존하므로 순차적으로 가져왔죠.

6.3 타임아웃 추가하기

API 호출이 너무 오래 걸릴 경우를 대비해 타임아웃을 추가하는 것도 좋은 방법이에요:

function timeout(ms) {
  return new Promise((_, reject) => {
    setTimeout(() => reject(new Error('타임아웃 발생!')), ms);
  });
}

async function fetchWithTimeout(url, ms = 5000) {
  try {
    // 두 프로미스 중 먼저 완료되는 것을 반환
    const response = await Promise.race([
      fetch(url),
      timeout(ms)
    ]);
    
    return await response.json();
  } catch (error) {
    console.error("Fetch 타임아웃 또는 오류:", error);
    throw error;
  }
}

Promise.race()를 사용하면 여러 프로미스 중 가장 먼저 완료되는 것의 결과를 얻을 수 있어요. 위 예제에서는 fetch가 타임아웃보다 먼저 완료되면 정상 응답을, 그렇지 않으면 타임아웃 에러를 반환해요.

6.4 재시도 로직 구현하기

async function fetchWithRetry(url, retries = 3, delay = 1000) {
  try {
    return await fetch(url).then(res => res.json());
  } catch (error) {
    if (retries <= 0) {
      throw error;
    }
    
    console.log(`재시도 중... 남은 시도: ${retries}`);
    
    // 지정된 시간만큼 대기
    await new Promise(resolve => setTimeout(resolve, delay));
    
    // 재귀적으로 재시도
    return fetchWithRetry(url, retries - 1, delay * 2);
  }
}

이 함수는 네트워크 오류가 발생할 경우 최대 3번까지 재시도하며, 각 시도 사이에 지수적으로 증가하는 대기 시간(1초, 2초, 4초)을 둬요. 이런 패턴은 일시적인 네트워크 문제를 극복하는 데 매우 유용해요!

async/await 실행 흐름 메인 스레드 (JavaScript 싱글 스레드) 동기 코드 실행 await fetchData() 중간 동기 코드 await processData() 완료 비동기 작업 진행 중 비동기 작업 진행 중 일시 중지 후 대기 일시 중지 후 대기 async/await는 비동기 작업을 기다리는 동안 JavaScript 메인 스레드를 차단하지 않고 다른 작업이 실행될 수 있게 합니다. 작업이 완료되면 중단된 지점부터 다시 실행됩니다.

7. async/await의 내부 동작 원리 🔍

async/await가 어떻게 작동하는지 궁금하지 않으세요? 사실 async/await는 제너레이터(Generator)와 프로미스(Promise)를 기반으로 한 문법적 설탕(Syntactic Sugar)이에요! 😮

간단히 말하면, async 함수는 제너레이터 함수를 자동으로 실행하는 특별한 런타임 환경을 제공해요. 이 환경은 yield 표현식(await로 대체됨)에서 함수 실행을 일시 중지하고, 프로미스가 해결되면 다시 실행을 재개해요.

예를 들어, 다음 async 함수는:

async function example() {
  const result1 = await doSomething();
  const result2 = await doSomethingElse(result1);
  return result2;
}

내부적으로는 이런 식으로 변환된다고 생각할 수 있어요:

function example() {
  return new Promise((resolve, reject) => {
    const generator = (function* () {
      try {
        const result1 = yield doSomething();
        const result2 = yield doSomethingElse(result1);
        resolve(result2);
      } catch (error) {
        reject(error);
      }
    })();
    
    function handle(result) {
      if (result.done) return;
      
      return Promise.resolve(result.value)
        .then(
          res => handle(generator.next(res)),
          err => handle(generator.throw(err))
        );
    }
    
    handle(generator.next());
  });
}

ㅋㅋㅋ 복잡해 보이죠? 그래서 async/await가 등장한 거예요! 개발자가 이런 복잡한 코드를 직접 작성하지 않아도 되게 해주는 거죠. 👍

이런 내부 동작을 이해하면 async/await의 몇 가지 특성을 더 잘 이해할 수 있어요:

  1. await는 프로미스가 해결될 때까지 함수 실행을 일시 중지하지만, JavaScript 엔진 자체는 계속 실행돼요 (비차단적)
  2. await 표현식은 프로미스의 해결된 값을 반환해요
  3. await 표현식에서 프로미스가 거부되면 예외가 발생해요 (try/catch로 잡을 수 있음)
  4. async 함수는 항상 프로미스를 반환해요

이런 내부 동작 원리를 알면 async/await를 더 효과적으로 사용할 수 있어요! 🧠

8. async/await의 장단점 ⚖️

모든 기술에는 장단점이 있죠. async/await도 예외는 아니에요! 이 섹션에서는 async/await의 장점과 단점을 살펴볼게요.

8.1 장점 👍

  1. 가독성 향상: 비동기 코드를 마치 동기 코드처럼 읽을 수 있어요. 코드 흐름을 따라가기가 훨씬 쉬워져요.
  2. 에러 처리 간소화: try/catch 블록을 사용해 동기 코드와 비동기 코드의 에러를 동일하게 처리할 수 있어요.
  3. 디버깅 용이성: 콜백이나 프로미스 체인보다 디버깅하기 쉬워요. 스택 트레이스가 더 명확하고, 중단점을 설정하기도 쉬워요.
  4. 조건부 로직 처리 용이: if/else 문과 같은 조건부 로직을 비동기 코드에 적용하기 쉬워져요.
  5. 중간 결과 활용 용이: 비동기 작업의 중간 결과를 변수에 저장하고 나중에 사용하기 쉬워요.

8.2 단점 👎

  1. 순차 실행의 함정: await를 잘못 사용하면 병렬로 실행할 수 있는 작업을 순차적으로 실행하게 되어 성능이 저하될 수 있어요.
  2. async 전파: 함수 하나가 async가 되면, 그 함수를 호출하는 다른 함수들도 async가 되어야 해요. 이것을 "async 전파"라고 해요.
  3. 브라우저 호환성: 오래된 브라우저에서는 트랜스파일러(Babel 등)나 폴리필 없이는 사용할 수 없어요.
  4. 에러 놓치기 쉬움: async 함수에서 반환된 프로미스의 rejection을 .catch()로 처리하지 않으면, 조용히 무시될 수 있어요 (UnhandledPromiseRejection).
  5. 남용 가능성: 모든 비동기 작업에 async/await를 사용하면 코드가 불필요하게 복잡해질 수 있어요. 간단한 경우에는 프로미스만으로도 충분할 수 있어요.

이런 단점들을 인지하고 적절히 대응하면, async/await의 장점을 최대한 활용할 수 있어요! 💪

9. 실전 예제: 재능넷 API 호출하기 🌐

이제 배운 내용을 종합해서 실전 예제를 만들어볼게요! 가상의 재능넷 API를 호출하는 코드를 작성해볼게요. 재능넷은 다양한 재능을 거래하는 플랫폼이니, 재능 검색과 관련된 기능을 구현해볼게요!

// 재능넷 API 클라이언트
class JaenungClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.jaenung.net/v1';
  }
  
  async fetchWithAuth(endpoint, options = {}) {
    const url = `${this.baseUrl}${endpoint}`;
    const headers = {
      'Authorization': `Bearer ${this.apiKey}`,
      'Content-Type': 'application/json',
      ...options.headers
    };
    
    try {
      const response = await fetch(url, {
        ...options,
        headers
      });
      
      if (!response.ok) {
        const errorData = await response.json().catch(() => ({}));
        throw new Error(`API 오류 (${response.status}): ${errorData.message || response.statusText}`);
      }
      
      return await response.json();
    } catch (error) {
      console.error(`재능넷 API 호출 실패 (${endpoint}):`, error);
      throw error;
    }
  }
  
  // 재능 검색 API
  async searchTalents(query, options = {}) {
    const queryParams = new URLSearchParams({
      q: query,
      page: options.page || 1,
      limit: options.limit || 20,
      category: options.category || '',
      sort: options.sort || 'relevance'
    }).toString();
    
    return this.fetchWithAuth(`/talents/search?${queryParams}`);
  }
  
  // 재능 상세 정보 API
  async getTalentDetails(talentId) {
    return this.fetchWithAuth(`/talents/${talentId}`);
  }
  
  // 관련 재능 추천 API
  async getRelatedTalents(talentId, limit = 5) {
    return this.fetchWithAuth(`/talents/${talentId}/related?limit=${limit}`);
  }
}

// 사용 예시
async function searchAndDisplayTalents() {
  try {
    const client = new JaenungClient('your-api-key');
    
    // 사용자 입력 받기 (실제로는 폼에서 가져올 수 있음)
    const searchQuery = '웹 개발';
    const category = 'programming';
    
    // 로딩 상태 표시
    document.getElementById('results').innerHTML = '검색 중...';
    
    // 재능 검색
    const searchResults = await client.searchTalents(searchQuery, {
      category,
      limit: 10,
      sort: 'rating'
    });
    
    console.log(`"${searchQuery}" 검색 결과:`, searchResults);
    
    // 결과가 없는 경우
    if (searchResults.items.length === 0) {
      document.getElementById('results').innerHTML = '검색 결과가 없습니다.';
      return;
    }
    
    // 첫 번째 결과의 상세 정보와 관련 재능을 병렬로 가져오기
    const firstTalentId = searchResults.items[0].id;
    const [details, relatedTalents] = await Promise.all([
      client.getTalentDetails(firstTalentId),
      client.getRelatedTalents(firstTalentId)
    ]);
    
    console.log('선택된 재능 상세 정보:', details);
    console.log('관련 재능:', relatedTalents);
    
    // 결과 표시 (실제로는 DOM 조작으로 UI에 표시)
    displayResults(searchResults, details, relatedTalents);
    
  } catch (error) {
    console.error('오류 발생:', error);
    document.getElementById('results').innerHTML = `오류가 발생했습니다: ${error.message}`;
  }
}

function displayResults(searchResults, details, relatedTalents) {
  // 실제 애플리케이션에서는 여기에 DOM 조작 코드가 들어갑니다
  document.getElementById('results').innerHTML = `
    <h3>${searchResults.items.length}개의 재능을 찾았습니다</h3>
    <div>
      <h4>선택된 재능: ${details.title}</h4>
      <p>${details.description}</p>
      <p>가격: ${details.price}원</p>
      <p>평점: ${details.rating}/5.0 (${details.reviewCount}개 리뷰)</p>
    </div>
    <div>
      <h4>관련 재능</h4>
      <ul>
        ${relatedTalents.items.map(talent => `<li>${talent.title} - ${talent.price}원</li>`).join('')}
      </ul>
    </div>
  `;
}

이 예제에서는 async/await를 사용해 재능넷 API와 상호 작용하는 클라이언트를 구현했어요. 주요 기능으로는:

  1. API 인증 및 오류 처리를 포함한 기본 fetch 래퍼
  2. 재능 검색, 상세 정보 조회, 관련 재능 추천 API
  3. 여러 API를 조합해 데이터를 가져오고 표시하는 함수
  4. Promise.all()을 사용한 병렬 API 호출

이런 방식으로 async/await를 활용하면 복잡한 API 상호 작용도 깔끔하고 관리하기 쉬운 코드로 작성할 수 있어요! 😄

10. 마무리 및 추가 학습 자료 📚

여기까지 JavaScript의 async/await에 대해 깊이 있게 알아봤어요! 비동기 프로그래밍의 기초부터 async/await의 내부 동작 원리, 실전 활용 팁까지 다양한 내용을 다뤘네요. 🎉

이제 여러분은 콜백 지옥에서 벗어나 깔끔하고 읽기 쉬운 비동기 코드를 작성할 수 있을 거예요! async/await는 현대 JavaScript 개발에서 필수적인 기술이니, 꼭 마스터하세요!

더 공부하고 싶다면 아래 자료들을 참고해보세요:

  1. MDN 웹 문서: async function
  2. MDN 웹 문서: await
  3. JavaScript.info: Async/await
  4. You Don't Know JS: Async & Performance

마지막으로, 비동기 프로그래밍은 연습이 중요해요! 직접 코드를 작성하고 실험해보면서 감각을 키워나가세요. 재능넷 같은 플랫폼에서 다른 개발자들의 코드를 참고하거나, 자신의 지식을 공유하는 것도 좋은 방법이에요. 함께 성장해요! 💪

여러분의 코딩 라이프에 async/await가 가져다 줄 편안함과 생산성 향상을 기대하며, 이만 마칠게요! 질문이나 피드백이 있으시면 언제든지 댓글로 남겨주세요! 👋

Happy coding! 그리고 비동기 세계에서 즐거운 여행 되세요! 🚀

댓글 작성

이 글에 대한 여러분의 생각을 들려주세요

댓글 0
댓글을 불러오는 중입니다.

아직 댓글이 없습니다.