⚙️ 13. 제너레이터 & 이터레이터 — 게으른 계산이 왜 강력한가

// 이터러블 프로토콜: [Symbol.iterator]() 메서드를 가진 객체
// 이터레이터 프로토콜: { value, done }을 반환하는 next() 메서드를 가진 객체
 
// 배열, 문자열, Map, Set 등은 이미 이터러블
const arr = [1, 2, 3];
const iterator = arr[Symbol.iterator](); // 이터레이터 가져오기
 
iterator.next(); // { value: 1, done: false }
iterator.next(); // { value: 2, done: false }
iterator.next(); // { value: 3, done: false }
iterator.next(); // { value: undefined, done: true }
 
// for...of는 내부적으로 이 과정을 자동화한 것
for (const val of [1, 2, 3]) {
  console.log(val); // 1, 2, 3
}
 
// 커스텀 이터러블 만들기
function range(start, end) {
  return {
    [Symbol.iterator]() {
      let current = start;
      return {
        next() {
          if (current <= end) {
            return { value: current++, done: false };
          }
          return { value: undefined, done: true };
        },
      };
    },
  };
}
 
for (const num of range(1, 5)) {
  console.log(num); // 1, 2, 3, 4, 5
}
 
console.log([...range(1, 5)]); // [1, 2, 3, 4, 5]

// function* — 제너레이터 함수 선언
function* simpleGenerator() {
  console.log("A");
  yield 1; // ← 여기서 일시 중단, 1을 반환
  console.log("B");
  yield 2; // ← 다시 일시 중단, 2를 반환
  console.log("C");
  return 3; // ← 함수 종료, { value: 3, done: true }
}
 
const gen = simpleGenerator(); // 함수 실행 안 됨!
 
gen.next(); // "A" 출력, { value: 1, done: false }
gen.next(); // "B" 출력, { value: 2, done: false }
gen.next(); // "C" 출력, { value: 3, done: true }
gen.next(); // { value: undefined, done: true }
 
// for...of로 순회 (return 값은 포함 안 됨)
for (const val of simpleGenerator()) {
  console.log(val); // 1, 2 (return 3은 포함 안 됨)
}

// 메모리에 무한 배열을 올릴 수는 없지만, 무한 제너레이터는 가능!
function* infiniteId() {
  let id = 1;
  while (true) {
    yield id++;
    // while(true)지만 yield에서 멈추므로 무한 루프가 아님
  }
}
 
const idGenerator = infiniteId();
idGenerator.next().value; // 1
idGenerator.next().value; // 2
idGenerator.next().value; // 3
// 필요할 때만 다음 값을 계산 → 메모리 효율적
 
// 처음 5개만 가져오기
function take(iterable, n) {
  const result = [];
  for (const val of iterable) {
    result.push(val);
    if (result.length >= n) break;
  }
  return result;
}
 
take(infiniteId(), 5); // [1, 2, 3, 4, 5]
 
// 영수네 커뮤니티 — 게시글 ID 자동 생성기
const postIdGen = infiniteId();
const newPost1 = { id: postIdGen.next().value, title: "첫 글" }; // id: 1
const newPost2 = { id: postIdGen.next().value, title: "두 번째" }; // id: 2

function* accumulator() {
  let total = 0;
  while (true) {
    const value = yield total; // yield는 외부에서 주입된 값을 반환
    if (value === null) break;
    total += value;
  }
}
 
const acc = accumulator();
acc.next();    // 시작, { value: 0, done: false }
acc.next(10);  // 10 주입, { value: 10, done: false }
acc.next(20);  // 20 주입, { value: 30, done: false }
acc.next(5);   // 5 주입, { value: 35, done: false }
acc.next(null); // 종료 신호, { value: undefined, done: true }

// 영수네 커뮤니티 — 전체 게시글 페이지네이션 처리
 
async function* fetchAllPosts(pageSize = 20) {
  let page = 1;
  let hasMore = true;
 
  while (hasMore) {
    const response = await fetch(
      `/api/posts?page=${page}&size=${pageSize}`
    );
    const { posts, total, currentPage } = await response.json();
 
    for (const post of posts) {
      yield post; // 한 번에 하나씩 yield
    }
 
    hasMore = currentPage * pageSize < total;
    page++;
  }
}
 
// 사용 — 전체 게시글을 스트리밍으로 처리
async function buildPostIndex() {
  const index = new Map();
 
  for await (const post of fetchAllPosts()) {
    // 한 번에 하나의 게시글만 메모리에 올려 처리
    index.set(post.id, {
      title: post.title,
      tags: post.tags,
    });
  }
 
  return index;
}
 
// 통계 처리
async function getPostStats() {
  let count = 0;
  let totalViews = 0;
  const tagFrequency = new Map();
 
  for await (const post of fetchAllPosts(50)) {
    count++;
    totalViews += post.viewCount;
 
    for (const tag of post.tags) {
      tagFrequency.set(tag, (tagFrequency.get(tag) ?? 0) + 1);
    }
  }
 
  return { count, totalViews, avgViews: totalViews / count, tagFrequency };
}

// 패턴 1: yield* — 다른 이터러블에 위임
function* combined() {
  yield* [1, 2, 3]; // 배열의 각 원소를 yield
  yield* "hello";   // 문자열의 각 문자를 yield
  yield 99;
}
 
[...combined()]; // [1, 2, 3, "h", "e", "l", "l", "o", 99]
 
// 패턴 2: 트리 순회 (재귀적 구조)
function* traverse(node) {
  yield node.value;
  for (const child of node.children ?? []) {
    yield* traverse(child); // 재귀적 위임
  }
}
 
const tree = {
  value: "root",
  children: [
    { value: "a", children: [{ value: "a1" }, { value: "a2" }] },
    { value: "b", children: [{ value: "b1" }] },
  ],
};
 
[...traverse(tree)]; // ["root", "a", "a1", "a2", "b", "b1"]
 
// 패턴 3: 배치 처리
async function* batchProcess(items, batchSize) {
  for (let i = 0; i < items.length; i += batchSize) {
    yield items.slice(i, i + batchSize);
  }
}
 
async function sendNotifications(userIds) {
  for await (const batch of batchProcess(userIds, 50)) {
    await Promise.all(batch.map((id) => sendNotification(id)));
    console.log(`${batch.length}명에게 알림 전송 완료`);
    await sleep(100); // 과부하 방지
  }
}

// for...of의 내부 동작 (의사 코드)
const iterable = [1, 2, 3];
const iterator = iterable[Symbol.iterator]();
 
let result = iterator.next();
while (!result.done) {
  // 루프 바디 실행
  console.log(result.value);
  result = iterator.next();
}
// 이것이 for (const val of iterable) { console.log(val); }와 동일

async function* streamAllPosts(pageSize = 100) {
  let page = 1;
  while (true) {
    const { posts, hasMore } = await fetchPosts({ page, pageSize });
    for (const post of posts) yield post;
    if (!hasMore) break;
    page++;
  }
}
 
async function analyzeTagStats() {
  const tagStats = new Map();
 
  for await (const post of streamAllPosts()) {
    for (const tag of post.tags) {
      tagStats.set(tag, (tagStats.get(tag) ?? 0) + 1);
    }
    // 메모리에는 현재 게시글 1개만 올라와 있음
    // 10만 개 처리해도 메모리는 일정
  }
 
  return tagStats;
}