Generator로 상태흐름 제어하기

function* countUp() {
  let i = 1;
  while (true) {
    yield i++;
  }
}
 
const counter = countUp();
console.log(counter.next().value); // 1
console.log(counter.next().value); // 2

function* countUp() {
  let i = 1;
  while (true) {
    yield i++;
  }
}
 
const counter = countUp();
console.log(counter.next().value); // 1
console.log(counter.next().value); // 2

  function* ex() {
    console.log('A');
    yield 1;         // 여기서 멈춤
    console.log('B');
    yield 2;         // 또 멈춤
    console.log('C');
    return 3;        // 끝남
  }
 
  const gen = ex();
 
  console.log(gen.next()); // A 출력 → { value: 1, done: false }
  console.log(gen.next()); // B 출력 → { value: 2, done: false }
  console.log(gen.next()); // C 출력 → { value: 3, done: true }

function* subGenerator() {
  yield 'a';
  yield 'b';
}
 
function* mainGenerator() {
  yield 1;
  yield* subGenerator(); // 여기서 위임
  yield 2;
}
 
for (const val of mainGenerator()) {
  console.log(val); // 1, 'a', 'b', 2
}

function* dialog() {
  const name = yield "이름이 뭐니?";
  yield `안녕, ${name}!`;
}
 
const g = dialog();
 
console.log(g.next());         // { value: '이름이 뭐니?', done: false }
console.log(g.next('광민'));   // { value: '안녕, 광민!', done: false }

function* ex() {
  const a = yield 'Ask A'; // → next(1)
  const b = yield 'Ask B'; // → next(2)
  return a + b;
}
 
const g = ex();
console.log(g.next());      // 'Ask A'
console.log(g.next(1));   // 'Ask B'
console.log(g.next(2));   // return 3

function* calc() {
  yield 1;
  return 999;
  yield 2; // 실행 안됨
}
 
const g = calc();
 
console.log(g.next()); // { value: 1, done: false }
console.log(g.next()); // { value: 999, done: true }
console.log(g.next()); // { value: undefined, done: true }

function* pageCounter() {
  // counter 변수는 제너레이터 내부에서만 관리됩니다.
  let counter = 0;
  while (true) {
    counter++;
    yield counter;
  }
}
 
// 제너레이터 인스턴스를 생성합니다.
const counterGen = pageCounter();
 
// 외부에서는 counterGen.next()를 통해서만 값을 얻을 수 있습니다.
console.log(counterGen.next().value); // 1
console.log(counterGen.next().value); // 2
console.log(counterGen.next().value); // 3
 
// ---------------------------------------------------
// 다른 제너레이터 인스턴스를 생성하여 상태의 독립성을 확인할 수 있습니다.
const anotherCounter = pageCounter();
console.log(anotherCounter.next().value); // 1 (다른 독립적인 상태)
console.log(anotherCounter.next().value); // 2
 
// ---------------------------------------------------
// 외부에서 제너레이터 내부의 counter 값을 직접 수정할 방법은 없습니다.
// 즉, counter는 제너레이터 스코프 내에 '폐쇄'되어 있어 외부 영향 없이 안전하게 관리됩니다.

async function* fetchPaginatedData() {
  let page = 1;
  while (true) {
    const res = await fetch(`/api/data?page=${page}`);
    const data = await res.json();
    if (data.length === 0) break;
 
    for (const item of data) {
      yield item;
    }
 
    page++;
  }
}
 
(async () => {
  for await (const item of fetchPaginatedData()) {
    console.log(item);
  }
})();

async function handleSignup(email, password) {
  try {
    const isExist = await checkAlreadyExist(email);
    if (isExist) throw new Error("이미 존재함");
 
    const registered = await registerUser(email, password);
    if (!registered.success) throw new Error("등록 실패");
 
    const loggedIn = await loginUser(email, password);
    return loggedIn;
  } catch (error) {
    console.error("회원가입 에러:", error.message);
    throw error;
  }
}

function* signupFlow(email, password) {
  yield { name: 'checkExist', task: checkAlreadyExist(email) };
  yield { name: 'register', task: registerUser(email, password) };
  yield { name: 'login', task: loginUser(email, password) };
}
 
 
async function runSignup(email, password) {
  const flow = signupFlow(email, password);
  let step = flow.next();
 
  while (!step.done) {
    const { name, task } = step.value;
    try {
      await task;
    } catch (err) {
      console.error(`🚨 [${name}] 에러:`, err.message);
      break;
    }
    step = flow.next();
  }
}