Async Generator Functions: 非同期イテレーションプロトコルの習得

            const asyncIterable = {
  [Symbol.asyncIterator]() {
    return {
      next() {
        // Asynchronously fetch the next value
      }
    };
  }
};

            

              
                Copy
              
            
          

            const asyncIterator = {
  next() {
    return new Promise((resolve) => {
      // Asynchronously fetch the next value
      setTimeout(() => {
        resolve({ value: /* some value */, done: false });
      }, 100);
    });
  },
  return() {
    return Promise.resolve({ value: undefined, done: true });
  },
  throw(error) {
    return Promise.reject(error);
  }
};

            

              
                Copy
              
            
          

            async function* myAsyncGenerator() {
  // Asynchronous operations and yield statements here
}

            

              
                Copy
              
            
          

            async function* fetchUsers() {
  const user1 = await fetch('https://example.com/api/users/1').then(res => res.json());
  yield user1;

  const user2 = await fetch('https://example.com/api/users/2').then(res => res.json());
  yield user2;

  const user3 = await fetch('https://example.com/api/users/3').then(res => res.json());
  yield user3;
}

            

              
                Copy
              
            
          

            async function main() {
  for await (const user of fetchUsers()) {
    console.log(user);
  }
}

main();

            

              
                Copy
              
            
          

            async function* fetchPaginatedData(url, pageSize = 10) {
  let page = 1;

  while (true) {
    const response = await fetch(`${url}?page=${page}&pageSize=${pageSize}`);
    const data = await response.json();

    if (data.length === 0) {
      return; // No more data
    }

    for (const item of data) {
      yield item;
    }

    page++;
  }
}

async function main() {
  for await (const item of fetchPaginatedData('https://api.example.com/data')) {
    console.log(item);
  }
}

main();

            

              
                Copy
              
            
          

            async function* fetchExchangeRates(currencyPair, startDate, endDate) {
  let currentDate = new Date(startDate);

  while (currentDate <= new Date(endDate)) {
    const dateString = currentDate.toISOString().split('T')[0]; // YYYY-MM-DD
    const url = `https://api.exchangerate.host/${dateString}?base=${currencyPair.substring(0,3)}&symbols=${currencyPair.substring(3,6)}`;
    try {
      const response = await fetch(url);
      const data = await response.json();

      if (data.success) {
        yield {
          date: dateString,
          rate: data.rates[currencyPair.substring(3,6)],
        };
      }

    } catch (error) {
      console.error(`Error fetching data for ${dateString}:`, error);
      // You might want to handle errors differently, e.g., retry or skip the date.
    }

    currentDate.setDate(currentDate.getDate() + 1);
  }
}

async function main() {
  const currencyPair = 'EURUSD';
  const startDate = '2023-01-01';
  const endDate = '2023-01-10';

  for await (const rate of fetchExchangeRates(currencyPair, startDate, endDate)) {
    console.log(rate);
  }
}

main();

            

              
                Copy
              
            
          

            const fs = require('fs');
const readline = require('readline');

async function* readLines(filePath) {
  const fileStream = fs.createReadStream(filePath);

  const rl = readline.createInterface({
    input: fileStream,
    crlfDelay: Infinity
  });

  for await (const line of rl) {
    yield line;
  }
}

async function main() {
  for await (const line of readLines('large_file.txt')) {
    // Process each line asynchronously
    console.log(line);
  }
}

main();

            

              
                Copy
              
            
          

            // This is a conceptual example and requires a WebSocket library like 'ws' (Node.js) or the browser's built-in WebSocket API.

async function* processWebSocketStream(url) {
  const websocket = new WebSocket(url);

  websocket.onmessage = (event) => {
    //This needs to be handled outside the generator.
    //Typically, you'd push the event.data into a queue
    //and the generator would asynchronously pull from the queue
    //via a Promise that resolves when data is available.
  };
  websocket.onerror = (error) => {
     //Handle errors.
  };
  websocket.onclose = () => {
    //Handle close.
  }

  //The actual yielding and queue management would happen here,
  //making use of Promises to synchronize between the websocket.onmessage
  //event and the async generator function.
  //This is a simplified illustration.

  //while(true){ //Use this if properly queuing events.
  //  const data = await new Promise((resolve) => {
  //   // Resolve the promise when data is available in the queue.
  //  })
  //  yield data
  //}

}

async function main() {
  // for await (const message of processWebSocketStream('wss://example.com/ws')) {
  //   console.log(message);
  // }
  console.log("WebSocket example - conceptual only. See comments in code for details.");
}

main();

            

              
                Copy
              
            
          

            async function* generateNumbers(start, end, delay) {
  for (let i = start; i <= end; i++) {
    await new Promise(resolve => setTimeout(resolve, delay));
    yield i;
  }
}

async function main() {
  for await (const number of generateNumbers(1, 5, 500)) {
    console.log(number);
  }
}

main();

            

              
                Copy
              
            
          

            async function* fetchData(url) {
  try {
    const response = await fetch(url);
    const data = await response.json();
    yield data;
  } catch (error) {
    console.error('Error fetching data:', error);
    // You can choose to re-throw the error, yield a default value, or stop the iteration.
    // For example, yield { error: error.message };
    throw error;
  }
}

async function main() {
  try {
    for await (const data of fetchData('https://example.com/api/invalid')) {
      console.log(data);
    }
  } catch (error) {
    console.error('Error during iteration:', error);
  }
}

main();

            

              
                Copy