Kombinator Iterator Asinkron JavaScript: Menguasai Operasi Stream untuk Pengembang Global

            async function* asyncNumberGenerator(limit) {
  for (let i = 1; i <= limit; i++) {
    await new Promise(resolve => setTimeout(resolve, 100)); // Mensimulasikan penundaan asinkron
    yield i;
  }
}

const generator = asyncNumberGenerator(5);

async function consumeGenerator() {
  let result;
  while (!(result = await generator.next()).done) {
    console.log(result.value);
  }
}

consumeGenerator();

            

              
                Copy
              
            
          

            async function* fetchUsers() {
  // Mensimulasikan pengambilan data pengguna dari endpoint API global
  const users = [
    { id: 1, name: 'Alice', address: { street: '123 Main St', city: 'Metropolis', country: 'USA' } },
    { id: 2, name: 'Bob', address: { street: '456 Oak Ave', city: 'London', country: 'UK' } },
    { id: 3, name: 'Chandra', address: { street: '789 Pine Ln', city: 'Mumbai', country: 'India' } }
  ];
  for (const user of users) {
    await new Promise(resolve => setTimeout(resolve, 50));
    yield user;
  }
}

// Fungsi pembantu untuk membuat kombinator map (konseptual)
function asyncMap(iterator, transformFn) {
  return (async function*() {
    let result;
    while (!(result = await iterator.next()).done) {
      yield transformFn(result.value);
    }
  })();
}

const formattedAddressesIterator = asyncMap(fetchUsers(), user =>
  `${user.address.street}, ${user.address.city}, ${user.address.country}`
);

async function displayAddresses() {
  console.log('--- Alamat yang Diformat ---');
  for await (const address of formattedAddressesIterator) {
    console.log(address);
  }
}

displayAddresses();

            

              
                Copy
              
            
          

            async function* fetchTransactions() {
  // Mensimulasikan pengambilan transaksi keuangan dengan mata uang dan jumlah
  const transactions = [
    { id: 'T1', amount: 150.75, currency: 'USD', region: 'North America' },
    { id: 'T2', amount: 80.50, currency: 'EUR', region: 'Europe' },
    { id: 'T3', amount: 250.00, currency: 'JPY', region: 'Asia' },
    { id: 'T4', amount: 45.20, currency: 'USD', region: 'North America' },
    { id: 'T5', amount: 180.00, currency: 'GBP', region: 'Europe' },
    { id: 'T6', amount: 300.00, currency: 'INR', region: 'Asia' }
  ];
  for (const tx of transactions) {
    await new Promise(resolve => setTimeout(resolve, 60));
    yield tx;
  }
}

// Fungsi pembantu untuk membuat kombinator filter (konseptual)
function asyncFilter(iterator, predicateFn) {
  return (async function*() {
    let result;
    while (!(result = await iterator.next()).done) {
      if (predicateFn(result.value)) {
        yield result.value;
      }
    }
  })();
}

const highValueUsdTransactionsIterator = asyncFilter(fetchTransactions(), tx =>
  tx.currency === 'USD' && tx.amount > 100
);

async function displayFilteredTransactions() {
  console.log('\n--- Transaksi USD Bernilai Tinggi ---');
  for await (const tx of highValueUsdTransactionsIterator) {
    console.log(`ID: ${tx.id}, Jumlah: ${tx.amount} ${tx.currency}`);
  }
}

displayFilteredTransactions();

            

              
                Copy
              
            
          

            // Menggunakan iterator fetchTransactions yang sama dari contoh filter

// Fungsi pembantu untuk membuat kombinator reduce (konseptual)
async function asyncReduce(iterator, reducerFn, initialValue) {
  let accumulator = initialValue;
  let result;
  while (!(result = await iterator.next()).done) {
    accumulator = await reducerFn(accumulator, result.value);
  }
  return accumulator;
}

async function calculateTotalValue() {
  const totalValue = await asyncReduce(
    fetchTransactions(),
    (sum, tx) => sum + tx.amount,
    0 // Jumlah awal
  );
  console.log(`\n--- Nilai Total Transaksi ---`);
  console.log(`Nilai total di semua transaksi: ${totalValue.toFixed(2)}`);
}

calculateTotalValue();

// Contoh: Menjumlahkan total untuk mata uang tertentu
async function calculateUsdTotal() {
  const usdTransactions = asyncFilter(fetchTransactions(), tx => tx.currency === 'USD');
  const usdTotal = await asyncReduce(
    usdTransactions,
    (sum, tx) => sum + tx.amount,
    0
  );
  console.log(`Nilai total untuk transaksi USD: ${usdTotal.toFixed(2)}`);
}

calculateUsdTotal();

            

              
                Copy
              
            
          

            async function* fetchProductsFromEu() {
  const products = [
    { id: 'E1', name: 'Laptop', price: 1200, origin: 'EU' },
    { id: 'E2', name: 'Keyboard', price: 75, origin: 'EU' }
  ];
  for (const prod of products) {
    await new Promise(resolve => setTimeout(resolve, 40));
    yield prod;
  }
}

async function* fetchProductsFromAsia() {
  const products = [
    { id: 'A1', name: 'Monitor', price: 300, origin: 'Asia' },
    { id: 'A2', name: 'Mouse', price: 25, origin: 'Asia' }
  ];
  for (const prod of products) {
    await new Promise(resolve => setTimeout(resolve, 45));
    yield prod;
  }
}

// Fungsi pembantu untuk membuat kombinator concat (konseptual)
function asyncConcat(...iterators) {
  return (async function*() {
    for (const iterator of iterators) {
      let result;
      while (!(result = await iterator.next()).done) {
        yield result.value;
      }
    }
  })();
}

const allProductsIterator = asyncConcat(fetchProductsFromEu(), fetchProductsFromAsia());

async function displayAllProducts() {
  console.log('\n--- Semua Produk (Digabungkan) ---');
  for await (const product of allProductsIterator) {
    console.log(`ID: ${product.id}, Nama: ${product.name}, Asal: ${product.origin}`);
  }
}

displayAllProducts();

            

              
                Copy
              
            
          

            async function* fetchFromServer(serverName, delay) {
  const data = [`${serverName}-data-1`, `${serverName}-data-2`, `${serverName}-data-3`];
  for (const item of data) {
    await new Promise(resolve => setTimeout(resolve, delay));
    yield item;
  }
}

// Gabungan konseptual: Bukan implementasi penuh, tetapi mengilustrasikan idenya.
// Implementasi nyata akan mengelola beberapa iterator secara bersamaan.
async function* conceptualAsyncMerge(...iterators) {
  // Versi yang disederhanakan ini mengiterasi melalui iterator secara berurutan,
  // tetapi gabungan yang sebenarnya akan menangani semua iterator secara konkuren.
  // Untuk demonstrasi, bayangkan mengambil data dari server dengan penundaan yang berbeda.
  const results = await Promise.all(iterators.map(async (it) => {
    const values = [];
    let result;
    while (!(result = await it.next()).done) {
      values.push(result.value);
    }
    return values;
  }));

  // Ratakan dan hasilkan semua hasil (gabungan sejati akan menyisipkannya)
  for (const serverResults of results) {
    for (const value of serverResults) {
      yield value;
    }
  }
}

// Untuk benar-benar mendemonstrasikan penggabungan, Anda memerlukan manajemen antrian/event loop yang lebih canggih.
// Untuk kesederhanaan, kita akan mensimulasikan dengan mengamati penundaan yang berbeda.

async function observeConcurrentFeeds() {
  console.log('\n--- Mengamati Umpan Konkuren ---');
  // Mensimulasikan pengambilan dari server dengan waktu respons yang berbeda
  const server1 = fetchFromServer('ServerA', 200);
  const server2 = fetchFromServer('ServerB', 100);
  const server3 = fetchFromServer('ServerC', 150);

  // Gabungan yang sebenarnya akan menghasilkan 'ServerB-data-1' terlebih dahulu, kemudian 'ServerC-data-1', dst.
  // Gabungan konseptual kita akan memprosesnya sesuai urutan penyelesaian.
  // Untuk implementasi praktis, pustaka seperti 'ixjs' menyediakan penggabungan yang tangguh.

  // Contoh yang disederhanakan menggunakan Promise.all lalu meratakannya (bukan penyisipan sejati)
  const allData = await Promise.all([
      Array.fromAsync(server1),
      Array.fromAsync(server2),
      Array.fromAsync(server3)
  ]);

  const mergedData = allData.flat();
  // Catatan: Urutan di sini tidak dijamin akan disisipkan seperti pada gabungan sejati
  // tanpa mekanisme penanganan Promise yang lebih kompleks.
  mergedData.forEach(data => console.log(data));
}

// Catatan: Array.fromAsync adalah tambahan modern untuk bekerja dengan iterator asinkron.
// Pastikan lingkungan Anda mendukungnya atau gunakan polyfill/pustaka.
// Jika Array.fromAsync tidak tersedia, iterasi manual diperlukan.

// Mari kita gunakan pendekatan manual jika Array.fromAsync tidak didukung secara universal
async function observeConcurrentFeedsManual() {
  console.log('\n--- Mengamati Umpan Konkuren (Iterasi Manual) ---');
  const iterators = [
    fetchFromServer('ServerX', 300),
    fetchFromServer('ServerY', 150),
    fetchFromServer('ServerZ', 250)
  ];

  const pendingPromises = iterators.map(async (it, index) => ({
    iterator: it,
    index: index,
    nextResult: await it.next()
  }));

  const results = [];
  while (pendingPromises.length > 0) {
    const { index, nextResult } = await Promise.race(pendingPromises.map(p => p.then(res => res)));

    if (!nextResult.done) {
      results.push(nextResult.value);
      console.log(nextResult.value);

      // Ambil item berikutnya dari iterator yang sama dan perbarui promise-nya
      const currentIterator = iterators[index];
      const nextPromise = (async () => {
        const next = await currentIterator.next();
        return { iterator: currentIterator, index: index, nextResult: next };
      })();
      // Ganti promise di pendingPromises dengan yang baru
      const promiseIndex = pendingPromises.findIndex(p => p.then(res => res.index === index));
      pendingPromises[promiseIndex] = nextPromise;
    } else {
      // Hapus promise untuk iterator yang telah selesai
      const promiseIndex = pendingPromises.findIndex(p => p.then(res => res.index === index));
      pendingPromises.splice(promiseIndex, 1);
    }
  }
}

observeConcurrentFeedsManual();

            

              
                Copy
              
            
          

            async function* streamSupportTickets() {
  let ticketId = 1001;
  while (true) {
    await new Promise(resolve => setTimeout(resolve, 75));
    yield { id: ticketId++, subject: 'Urgent issue', status: 'Open' };
  }
}

// Fungsi pembantu untuk membuat kombinator take (konseptual)
function asyncTake(iterator, count) {
  return (async function*() {
    let yieldedCount = 0;
    let result;
    while (yieldedCount < count && !(result = await iterator.next()).done) {
      yield result.value;
      yieldedCount++;
    }
  })();
}

const top5TicketsIterator = asyncTake(streamSupportTickets(), 5);

async function displayTopTickets() {
  console.log('\n--- 5 Tiket Dukungan Teratas ---');
  for await (const ticket of top5TicketsIterator) {
    console.log(`ID: ${ticket.id}, Subjek: ${ticket.subject}`);
  }
}

displayTopTickets();

            

              
                Copy
              
            
          

            async function* streamSystemLogs() {
  const logs = [
    'Sistem memulai...', 'Inisialisasi layanan...', 'Menghubungkan ke database...',
    'Pengguna masuk: admin', 'Memproses permintaan ID 123', 'Permintaan berhasil diproses',
    'Pengguna masuk: guest', 'Memproses permintaan ID 124', 'Permintaan berhasil diproses'
  ];
  for (const log of logs) {
    await new Promise(resolve => setTimeout(resolve, 30));
    yield log;
  }
}

// Fungsi pembantu untuk membuat kombinator skip (konseptual)
function asyncSkip(iterator, count) {
  return (async function*() {
    let skippedCount = 0;
    let result;
    while (skippedCount < count && !(result = await iterator.next()).done) {
      skippedCount++;
    }
    // Sekarang lanjutkan menghasilkan dari tempat kita berhenti
    while (!(result = await iterator.next()).done) {
      yield result.value;
    }
  })();
}

const relevantLogsIterator = asyncSkip(streamSystemLogs(), 3); // Lewati pesan awal

async function displayRelevantLogs() {
  console.log('\n--- Log Sistem yang Relevan ---');
  for await (const log of relevantLogsIterator) {
    console.log(log);
  }
}

displayRelevantLogs();

            

              
                Copy
              
            
          

            async function* fetchProductsForCategory(categoryName) {
  const products = [
    { name: `Produk ${categoryName} A`, price: 50 },
    { name: `Produk ${categoryName} B`, price: 75 }
  ];
  for (const product of products) {
    await new Promise(resolve => setTimeout(resolve, 20));
    yield product;
  }
}

async function* fetchCategories() {
  const categories = ['Elektronik', 'Buku', 'Pakaian'];
  for (const category of categories) {
    await new Promise(resolve => setTimeout(resolve, 50));
    // Menghasilkan iterator asinkron untuk produk dalam kategori ini
    yield fetchProductsForCategory(category);
  }
}

// Fungsi pembantu untuk membuat kombinator flatten (konseptual)
function asyncFlatten(iteratorOfIterators) {
  return (async function*() {
    let result;
    while (!(result = await iteratorOfIterators.next()).done) {
      const innerIterator = result.value;
      let innerResult;
      while (!(innerResult = await innerIterator.next()).done) {
        yield innerResult.value;
      }
    }
  })();
}

const allProductsFlattenedIterator = asyncFlatten(fetchCategories());

async function displayFlattenedProducts() {
  console.log('\n--- Semua Produk (Diratakan) ---');
  for await (const product of allProductsFlattenedIterator) {
    console.log(`Produk: ${product.name}, Harga: ${product.price}`);
  }
}

displayFlattenedProducts();

            

              
                Copy
              
            
          

            const processedData = asyncTake(
  asyncFilter(asyncMap(fetchUsers(), user => ({ ...user, fullName: `${user.name} Doe` })), user => user.id > 1),
  3
);

// Rantai ini pertama-tama memetakan pengguna untuk menambahkan fullName, lalu memfilter pengguna pertama,
// dan akhirnya mengambil 3 pengguna pertama yang tersisa.

            

              
                Copy