ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள்: உலகளாவிய டெவலப்பர்களுக்கான ஸ்ட்ரீம் செயல்பாடுகளில் தேர்ச்சி பெறுதல்

இன்றைய ஒன்றோடொன்று இணைக்கப்பட்ட டிஜிட்டல் உலகில், ஒத்திசைவற்ற டேட்டா ஸ்ட்ரீம்களை திறமையாகக் கையாள்வது மிக முக்கியம். உலகெங்கிலும் உள்ள டெவலப்பர்கள், நிகழ்நேர டேட்டா செயலாக்கம் முதல் ஊடாடும் பயனர் இடைமுகங்கள் வரை பெருகிய முறையில் சிக்கலான பயன்பாடுகளைச் சமாளிக்கும்போது, ஒத்திசைவற்ற டேட்டாவின் ஸ்ட்ரீம்களை நேர்த்தியாகவும் கட்டுப்பாட்டுடனும் கையாளும் திறன் ஒரு முக்கியமான திறமையாகிறது. ஜாவாஸ்கிரிப்ட்டின் அசிங்க் இட்டரேட்டர்கள் அறிமுகம் இந்த ஸ்ட்ரீம்களை நிர்வகிப்பதற்கான மிகவும் இயல்பான மற்றும் சக்திவாய்ந்த வழிகளுக்கு வழிவகுத்துள்ளது. இருப்பினும், அவற்றின் முழு திறனையும் பயன்படுத்த, அவற்றை ஒன்றிணைக்கவும் மாற்றவும் அனுமதிக்கும் கருவிகள் நமக்குத் தேவை – இங்குதான் அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள் பிரகாசிக்கின்றன.

இந்த விரிவான வலைப்பதிவு இடுகை, ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களின் உலகிற்கு உங்களை வழிநடத்தும். அவை என்ன, உலகளாவிய மேம்பாட்டிற்கு ஏன் அவை அவசியமானவை என்பதை நாம் ஆராய்வோம், மேலும் மேப்பிங், ஃபில்டரிங், ரெடியூசிங் போன்ற பொதுவான ஸ்ட்ரீம் செயல்பாடுகளின் நடைமுறை, சர்வதேச அளவில் பொருத்தமான எடுத்துக்காட்டுகளை ஆழமாகப் பார்ப்போம். உலகளாவிய டெவலப்பராகிய உங்களுக்கு, அதிக செயல்திறன், பராமரிக்கக்கூடிய மற்றும் வலுவான ஒத்திசைவற்ற பயன்பாடுகளை உருவாக்குவதற்கான அறிவை வழங்குவதே எங்கள் குறிக்கோள்.

அசிங்க் இட்டரேட்டர்களைப் புரிந்துகொள்ளுதல்: அடிப்படை

காம்பினேட்டர்களுக்குள் செல்வதற்கு முன், அசிங்க் இட்டரேட்டர்கள் என்றால் என்ன என்பதைச் சுருக்கமாக நினைவுபடுத்துவோம். ஒரு அசிங்க் இட்டரேட்டர் என்பது ஒரு ஆப்ஜெக்ட் ஆகும், இது ஒரு டேட்டா வரிசையை வரையறுக்கிறது, அங்கு ஒவ்வொரு `next()` அழைப்பும் ஒரு Promise-ஐ வழங்கும், அது ஒரு { value: T, done: boolean } ஆப்ஜெக்ட்டாகத் தீர்க்கப்படும். இது சின்க்ரோனஸ் இட்டரேட்டர்களிடமிருந்து அடிப்படையில் வேறுபட்டது, அவை சாதாரண மதிப்புகளை வழங்குகின்றன.

அசிங்க் இட்டரேட்டர்களின் முக்கிய நன்மை, உடனடியாகக் கிடைக்காத வரிசைகளைக் குறிக்கும் திறனில் உள்ளது. இது பின்வருவனவற்றிற்கு நம்பமுடியாத அளவிற்கு பயனுள்ளதாக இருக்கும்:

• நெட்வொர்க் கோரிக்கைகளிலிருந்து டேட்டாவைப் படித்தல் (எ.கா., பக்கமிடப்பட்ட API முடிவுகளைப் பெறுதல்).
• பெரிய கோப்புகளை முழு கோப்பையும் மெமரியில் ஏற்றாமல் பகுதிகளாகச் செயலாக்குதல்.
• நிகழ்நேர டேட்டா ஊட்டங்களைக் கையாளுதல் (எ.கா., WebSocket செய்திகள்).
• காலப்போக்கில் மதிப்புகளை உருவாக்கும் ஒத்திசைவற்ற செயல்பாடுகளை நிர்வகித்தல்.

அசிங்க் இட்டரேட்டர் புரோட்டோகால், ஒரு [Symbol.asyncIterator] முறையின் இருப்பால் வரையறுக்கப்படுகிறது, இது ஒரு next() முறையுடன் ஒரு ஆப்ஜெக்ட்டை வழங்குகிறது, அந்த முறை ஒரு Promise-ஐ வழங்குகிறது.

இங்கே ஒரு அசிங்க் இட்டரேட்டரின் எளிய எடுத்துக்காட்டு:

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

const generator = asyncNumberGenerator(5);

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

consumeGenerator();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டு, ஒரு தாமதத்துடன் எண்களை வழங்கும் ஒரு ஜெனரேட்டர் செயல்பாட்டைக் காட்டுகிறது. for await...of லூப், அசிங்க் இட்டரேட்டர்களைப் பயன்படுத்துவதற்கான ஒரு வசதியான தொடரியலை வழங்குகிறது.

அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களின் தேவை

அசிங்க் இட்டரேட்டர்கள் ஒத்திசைவற்ற வரிசைகளை உருவாக்க மற்றும் நுகர அனுமதிக்கும் அதே வேளையில், இந்த வரிசைகளில் சிக்கலான செயல்பாடுகளைச் செய்வதற்கு பெரும்பாலும் பாய்லர்ப்ளேட் குறியீடு தேவைப்படுகிறது. பல பக்கமிடப்பட்ட API-களிலிருந்து டேட்டாவைப் பெறுதல், குறிப்பிட்ட நிபந்தனைகளின் அடிப்படையில் முடிவுகளை வடிகட்டுதல், பின்னர் அந்த முடிவுகளைச் செயலாக்குவதற்கு முன்பு மாற்றுதல் ஆகியவற்றை கற்பனை செய்து பாருங்கள். காம்பினேட்டர்கள் இல்லாமல், இது நெஸ்ட் செய்யப்பட்ட லூப்கள் மற்றும் சிக்கலான தர்க்கத்திற்கு வழிவகுக்கும்.

அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள் உயர்-வரிசை செயல்பாடுகள் ஆகும், அவை ஒன்று அல்லது அதற்கு மேற்பட்ட அசிங்க் இட்டரேட்டர்களை உள்ளீடாக எடுத்து, மாற்றப்பட்ட அல்லது ஒருங்கிணைக்கப்பட்ட வரிசையைக் குறிக்கும் ஒரு புதிய அசிங்க் இட்டரேட்டரை வழங்குகின்றன. அவை பின்வருவன போன்ற ஃபங்ஷனல் புரோகிராமிங் முன்னுதாரணங்களைப் போன்ற ஒரு அறிவிப்பு மற்றும் தொகுக்கக்கூடிய புரோகிராமிங் பாணியை செயல்படுத்துகின்றன:

• Map: ஒரு வரிசையில் உள்ள ஒவ்வொரு உறுப்பையும் மாற்றுதல்.
• Filter: ஒரு குறிப்பிட்ட நிபந்தனையை பூர்த்தி செய்யும் உறுப்புகளைத் தேர்ந்தெடுப்பது.
• Reduce: உறுப்புகளை ஒரே மதிப்பாகத் திரட்டுதல்.
• Combine: பல வரிசைகளை ஒன்றிணைத்தல்.
• Concurrency Control: இணை செயல்பாட்டை நிர்வகித்தல்.

இந்த பொதுவான வடிவங்களை சுருக்கமாகக் கூறுவதன் மூலம், காம்பினேட்டர்கள் குறியீடு வாசிப்புத்திறன், மறுபயன்பாடு மற்றும் பராமரிப்புத்திறனை கணிசமாக மேம்படுத்துகின்றன. உலகளாவிய மேம்பாட்டு சூழல்களில் இது மிகவும் மதிப்புமிக்கது, அங்கு ஒத்துழைப்பு மற்றும் சிக்கலான ஒத்திசைவற்ற பாய்வுகளைப் புரிந்துகொள்வது முக்கியமானது.

முக்கிய அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள் மற்றும் அவற்றின் பயன்பாடுகள்

சில அடிப்படை அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களை ஆராய்ந்து, நடைமுறை, உலகளவில் பொருத்தமான சூழ்நிலைகளுடன் அவற்றின் பயன்பாட்டை விளக்குவோம்.

1. `map()`: ஸ்ட்ரீம் உறுப்புகளை மாற்றுதல்

`map` காம்பினேட்டர் கொடுக்கப்பட்ட ஒரு செயல்பாட்டை ஒரு அசிங்க் இட்டரேட்டரால் வெளியிடப்பட்ட ஒவ்வொரு உறுப்பிற்கும் பயன்படுத்துகிறது, மாற்றப்பட்ட மதிப்புகளை வழங்கும் ஒரு புதிய அசிங்க் இட்டரேட்டரை வழங்குகிறது.

சூழல்: நெஸ்ட் செய்யப்பட்ட முகவரி விவரங்களுடன் பயனர் ஆப்ஜெக்ட்களை வழங்கும் ஒரு API-இலிருந்து பயனர் தரவைப் பெறுவதாகக் கற்பனை செய்து கொள்ளுங்கள். ஒவ்வொரு பயனருக்கும் முழு முகவரியைப் பிரித்தெடுத்து வடிவமைக்க விரும்புகிறோம்.

            async function* fetchUsers() {
  // Simulate fetching user data from a global API endpoint
  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;
  }
}

// A helper function to create a map combinator (conceptual)
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('--- Formatted Addresses ---');
  for await (const address of formattedAddressesIterator) {
    console.log(address);
  }
}

displayAddresses();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `asyncMap` நமது `fetchUsers` அசிங்க் இட்டரேட்டரையும் ஒரு மாற்றும் செயல்பாட்டையும் எடுக்கிறது. மாற்றும் செயல்பாடு முகவரி ஆப்ஜெக்டை ஒரு படிக்கக்கூடிய ஸ்டிரிங்காக வடிவமைக்கிறது. இந்த முறை வெவ்வேறு சர்வதேச மூலங்களிலிருந்து வரும் தரவு வடிவங்களை தரப்படுத்துவதற்கு மிகவும் மறுபயன்பாட்டுக்குரியது.

2. `filter()`: ஸ்ட்ரீம் உறுப்புகளைத் தேர்ந்தெடுத்தல்

`filter` காம்பினேட்டர் ஒரு பிரிடிகேட் செயல்பாட்டையும் ஒரு அசிங்க் இட்டரேட்டரையும் எடுக்கிறது. இது ஒரு புதிய அசிங்க் இட்டரேட்டரை வழங்குகிறது, இது பிரிடிகேட் செயல்பாடு ட்ரூ என்று திருப்பியனுப்பும் உறுப்புகளை மட்டுமே வழங்குகிறது.

சூழல்: நாம் பல்வேறு உலகளாவிய சந்தைகளிலிருந்து நிதி பரிவர்த்தனைகளின் ஒரு ஸ்ட்ரீமைச் செயலாக்குகிறோம். ஒரு குறிப்பிட்ட பிராந்தியத்திலிருந்து வரும் பரிவர்த்தனைகள் அல்லது ஒரு குறிப்பிட்ட மதிப்பு வரம்பிற்குக் கீழே உள்ளவற்றை நாம் வடிகட்ட வேண்டும்.

            async function* fetchTransactions() {
  // Simulate fetching financial transactions with currency and amount
  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;
  }
}

// A helper function to create a filter combinator (conceptual)
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--- High Value USD Transactions ---');
  for await (const tx of highValueUsdTransactionsIterator) {
    console.log(`ID: ${tx.id}, Amount: ${tx.amount} ${tx.currency}`);
  }
}

displayFilteredTransactions();

            

              
                Copy
              
            
          

இங்கே, `asyncFilter` பரிவர்த்தனைகளின் ஒரு ஸ்ட்ரீமைத் திறமையாகச் செயலாக்க அனுமதிக்கிறது, நமது நிபந்தனைகளைப் பூர்த்தி செய்பவற்றை மட்டும் வைத்துக்கொள்கிறது. இது நிதி பகுப்பாய்வு, மோசடி கண்டறிதல், அல்லது பல்வேறு உலகளாவிய நிதி அமைப்புகள் முழுவதும் அறிக்கையிடுவதற்கு முக்கியமானது.

3. `reduce()`: ஸ்ட்ரீம் உறுப்புகளைத் திரட்டுதல்

`reduce` காம்பினேட்டர் (பெரும்பாலும் `fold` அல்லது `aggregate` என்று அழைக்கப்படுகிறது) ஒரு அசிங்க் இட்டரேட்டர் வழியாகச் சென்று, ஒவ்வொரு உறுப்பிற்கும் ஒரு திரட்டி செயல்பாட்டையும் ஒரு இயங்கும் மொத்தத்தையும் பயன்படுத்துகிறது. இது இறுதியில் ஒரு திரட்டப்பட்ட மதிப்பிற்குத் தீர்க்கிறது.

சூழல்: ஒரு குறிப்பிட்ட நாணயத்தில் உள்ள அனைத்து பரிவர்த்தனைகளின் மொத்த மதிப்பைக் கணக்கிடுதல், அல்லது வெவ்வேறு பிராந்தியக் கிடங்குகளிலிருந்து செயலாக்கப்பட்ட பொருட்களின் எண்ணிக்கையைக் கூட்டுதல்.

            // Using the same fetchTransactions iterator from the filter example

// A helper function to create a reduce combinator (conceptual)
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 // Initial sum
  );
  console.log(`\n--- Total Transaction Value ---`);
  console.log(`Total value across all transactions: ${totalValue.toFixed(2)}`);
}

calculateTotalValue();

// Example: Summing amounts for a specific currency
async function calculateUsdTotal() {
  const usdTransactions = asyncFilter(fetchTransactions(), tx => tx.currency === 'USD');
  const usdTotal = await asyncReduce(
    usdTransactions,
    (sum, tx) => sum + tx.amount,
    0
  );
  console.log(`Total value for USD transactions: ${usdTotal.toFixed(2)}`);
}

calculateUsdTotal();

            

              
                Copy
              
            
          

`asyncReduce` செயல்பாடு ஸ்ட்ரீமிலிருந்து ஒரு ஒற்றை மதிப்பைத் திரட்டுகிறது. இது சுருக்கங்களை உருவாக்குதல், அளவீடுகளைக் கணக்கிடுதல், அல்லது பல்வேறு உலகளாவிய மூலங்களிலிருந்து வரும் பெரிய டேட்டாசெட்களில் திரட்டல்களைச் செய்வதற்கு அடிப்படையானது.

4. `concat()`: ஸ்ட்ரீம்களை வரிசையாக இணைத்தல்

`concat` காம்பினேட்டர் பல அசிங்க் இட்டரேட்டர்களை எடுத்து, ஒவ்வொரு உள்ளீட்டு இட்டரேட்டரிலிருந்தும் வரிசையாக உறுப்புகளை வழங்கும் ஒரு புதிய அசிங்க் இட்டரேட்டரை வழங்குகிறது.

சூழல்: தொடர்புடைய தகவல்களை வழங்கும் இரண்டு வெவ்வேறு API எண்ட்பாயிண்ட்களிலிருந்து டேட்டாவை ஒன்றிணைத்தல், உதாரணமாக ஐரோப்பிய கிடங்கு மற்றும் ஆசிய கிடங்கிலிருந்து தயாரிப்பு பட்டியல்கள்.

            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;
  }
}

// A helper function to create a concat combinator (conceptual)
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--- All Products (Concatenated) ---');
  for await (const product of allProductsIterator) {
    console.log(`ID: ${product.id}, Name: ${product.name}, Origin: ${product.origin}`);
  }
}

displayAllProducts();

            

              
                Copy
              
            
          

`asyncConcat` வெவ்வேறு புவியியல் இருப்பிடங்கள் அல்லது வேறுபட்ட தரவு மூலங்களிலிருந்து வரும் டேட்டா ஸ்ட்ரீம்களை ஒரு ஒற்றை, ஒத்திசைவான வரிசையாக ஒருங்கிணைப்பதற்கு ஏற்றது.

5. `merge()` (அல்லது `race()`): ஸ்ட்ரீம்களை ஒரே நேரத்தில் இணைத்தல்

`concat` போலல்லாமல், `merge` (அல்லது விரும்பிய நடத்தைக்கு ஏற்ப `race`) பல அசிங்க் இட்டரேட்டர்களை ஒரே நேரத்தில் செயலாக்குகிறது. `merge` எந்தவொரு உள்ளீட்டு இட்டரேட்டர்களிடமிருந்தும் மதிப்புகள் கிடைக்கும்போது அவற்றை வழங்குகிறது. `race` எந்த இட்டரேட்டரிலிருந்தும் முதல் மதிப்பை வழங்கிவிட்டு, பின்னர் செயலாக்கத்தைப் பொறுத்து நிறுத்தலாம் அல்லது தொடரலாம்.

சூழல்: பல பிராந்திய சர்வர்களிலிருந்து ஒரே நேரத்தில் தரவைப் பெறுதல். ஒவ்வொரு சர்வரின் முழு டேட்டாசெட்டிற்காகவும் காத்திருக்காமல், எந்தவொரு சர்வரிலிருந்தும் தரவு கிடைத்தவுடன் அதைச் செயலாக்க விரும்புகிறோம்.

ஒரு வலுவான `merge` காம்பினேட்டரை செயல்படுத்துவது சிக்கலானதாக இருக்கலாம், பல நிலுவையில் உள்ள ப்ராமிஸ்களை கவனமாக நிர்வகிப்பது இதில் அடங்கும். இங்கே ஒரு எளிமைப்படுத்தப்பட்ட கருத்தியல் எடுத்துக்காட்டு, தரவு வரும்போது அதை வழங்கும் யோசனையில் கவனம் செலுத்துகிறது:

            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;
  }
}

// Conceptual merge: Not a full implementation, but illustrates the idea.
// A real implementation would manage multiple iterators simultaneously.
async function* conceptualAsyncMerge(...iterators) {
  // This simplified version iterates through iterators sequentially,
  // but a true merge would handle all iterators concurrently.
  // For demonstration, imagine fetching from servers with different delays.
  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;
  }));

  // Flatten and yield all results (a true merge would interleave)
  for (const serverResults of results) {
    for (const value of serverResults) {
      yield value;
    }
  }
}

// To truly demonstrate merge, you'd need a more sophisticated queue/event loop management.
// For simplicity, we'll simulate by observing different delays.

async function observeConcurrentFeeds() {
  console.log('\n--- Observing Concurrent Feeds ---');
  // Simulate fetching from servers with different response times
  const server1 = fetchFromServer('ServerA', 200);
  const server2 = fetchFromServer('ServerB', 100);
  const server3 = fetchFromServer('ServerC', 150);

  // A real merge would yield 'ServerB-data-1' first, then 'ServerC-data-1', etc.
  // Our conceptual merge will process them in the order they complete.
  // For a practical implementation, libraries like 'ixjs' provide robust merge.

  // Simplified example using Promise.all and then flattening (not true interleaving)
  const allData = await Promise.all([
      Array.fromAsync(server1),
      Array.fromAsync(server2),
      Array.fromAsync(server3)
  ]);

  const mergedData = allData.flat();
  // Note: The order here is not guaranteed to be interleaved as in a true merge
  // without a more complex Promise handling mechanism.
  mergedData.forEach(data => console.log(data));
}

// Note: Array.fromAsync is a modern addition to work with async iterators.
// Ensure your environment supports it or use a polyfill/library.
// If Array.fromAsync is not available, manual iteration is needed.

// Let's use a manual approach if Array.fromAsync isn't universally supported
async function observeConcurrentFeedsManual() {
  console.log('\n--- Observing Concurrent Feeds (Manual Iteration) ---');
  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);

      // Fetch the next item from the same iterator and update its promise
      const currentIterator = iterators[index];
      const nextPromise = (async () => {
        const next = await currentIterator.next();
        return { iterator: currentIterator, index: index, nextResult: next };
      })();
      // Replace the promise in pendingPromises with the new one
      const promiseIndex = pendingPromises.findIndex(p => p.then(res => res.index === index));
      pendingPromises[promiseIndex] = nextPromise;
    } else {
      // Remove the promise for the completed iterator
      const promiseIndex = pendingPromises.findIndex(p => p.then(res => res.index === index));
      pendingPromises.splice(promiseIndex, 1);
    }
  }
}

observeConcurrentFeedsManual();

            

              
                Copy
              
            
          

கைமுறை `observeConcurrentFeedsManual` செயல்பாடு, `Promise.race`-இன் முக்கிய யோசனையை விளக்குகிறது, இது முன்கூட்டியே கிடைக்கும் முடிவைத் தேர்ந்தெடுக்கிறது. இது மெதுவான தரவு மூலங்களில் முடக்காத பதிலளிக்கக்கூடிய அமைப்புகளை உருவாக்குவதற்கு முக்கியமானது, இது பல்வேறு உலகளாவிய உள்கட்டமைப்புகளுடன் ஒருங்கிணைக்கும்போது ஒரு பொதுவான சவாலாகும்.

6. `take()`: ஸ்ட்ரீம் நீளத்தைக் கட்டுப்படுத்துதல்

`take` காம்பினேட்டர் ஒரு புதிய அசிங்க் இட்டரேட்டரை வழங்குகிறது, இது மூல இட்டரேட்டரிலிருந்து முதல் N உறுப்புகளை மட்டுமே வழங்குகிறது.

சூழல்: தொடர்ந்து புதுப்பிக்கப்படும் ஒரு ஸ்ட்ரீமிலிருந்து, எத்தனை இருந்தாலும், முதல் 5 சமீபத்திய வாடிக்கையாளர் ஆதரவு டிக்கெட்டுகளை மட்டும் மீட்டெடுத்தல்.

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

// A helper function to create a take combinator (conceptual)
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--- Top 5 Support Tickets ---');
  for await (const ticket of top5TicketsIterator) {
    console.log(`ID: ${ticket.id}, Subject: ${ticket.subject}`);
  }
}

displayTopTickets();

            

              
                Copy
              
            
          

`asyncTake` பக்கப்பிரிப்பு, தரவு மாதிரியாக்கம், அல்லது சாத்தியமான எல்லையற்ற ஸ்ட்ரீம்களைக் கையாளும்போது வள நுகர்வைக் கட்டுப்படுத்துவதற்கு பயனுள்ளதாக இருக்கும்.

7. `skip()`: ஆரம்ப ஸ்ட்ரீம் உறுப்புகளைத் தவிர்த்தல்

`skip` காம்பினேட்டர் ஒரு புதிய அசிங்க் இட்டரேட்டரை வழங்குகிறது, இது மூல இட்டரேட்டரிலிருந்து முதல் N உறுப்புகளைத் தவிர்த்து, மீதமுள்ளவற்றை வழங்குகிறது.

சூழல்: பதிவு கோப்புகள் அல்லது நிகழ்வு ஸ்ட்ரீம்களைச் செயலாக்கும்போது, ஆரம்ப அமைப்பு அல்லது இணைப்பு செய்திகளைப் புறக்கணித்து, ஒரு குறிப்பிட்ட இடத்திலிருந்து செயலாக்கத் தொடங்க விரும்பலாம்.

            async function* streamSystemLogs() {
  const logs = [
    'System starting...', 'Initializing services...', 'Connecting to database...', 
    'User logged in: admin', 'Processing request ID 123', 'Request processed successfully', 
    'User logged in: guest', 'Processing request ID 124', 'Request processed successfully'
  ];
  for (const log of logs) {
    await new Promise(resolve => setTimeout(resolve, 30));
    yield log;
  }
}

// A helper function to create a skip combinator (conceptual)
function asyncSkip(iterator, count) {
  return (async function*() {
    let skippedCount = 0;
    let result;
    while (skippedCount < count && !(result = await iterator.next()).done) {
      skippedCount++;
    }
    // Now continue yielding from where we left off
    while (!(result = await iterator.next()).done) {
      yield result.value;
    }
  })();
}

const relevantLogsIterator = asyncSkip(streamSystemLogs(), 3); // Skip initial messages

async function displayRelevantLogs() {
  console.log('\n--- Relevant System Logs ---');
  for await (const log of relevantLogsIterator) {
    console.log(log);
  }
}

displayRelevantLogs();

            

              
                Copy
              
            
          

`asyncSkip` ஒரு தரவு ஸ்ட்ரீமின் அர்த்தமுள்ள பகுதியில் கவனம் செலுத்த உதவுகிறது, குறிப்பாக verbose அல்லது நிலை-மாற்றும் ஆரம்ப வரிசைகளைக் கையாளும்போது.

8. `flatten()`: நெஸ்ட் செய்யப்பட்ட இட்டரேட்டர்களை அவிழ்த்தல்

`flatten` காம்பினேட்டர் (சில சமயங்களில் மேப்பிங்குடன் இணைக்கப்படும்போது `flatMap` என்று அழைக்கப்படுகிறது) மற்ற அசிங்க் இட்டரேட்டர்களை வழங்கும் ஒரு அசிங்க் இட்டரேட்டரை எடுத்து, உள் இட்டரேட்டர்களிலிருந்து அனைத்து உறுப்புகளையும் வழங்கும் ஒரு ஒற்றை அசிங்க் இட்டரேட்டரை வழங்குகிறது.

சூழல்: ஒரு API வகைகளின் பட்டியலை வழங்கலாம், அங்கு ஒவ்வொரு வகை ஆப்ஜெக்ட்டும் அதன் தொடர்புடைய தயாரிப்புகளுக்கான ஒரு அசிங்க் இட்டரேட்டரைக் கொண்டிருக்கும். `flatten` இந்த கட்டமைப்பை அவிழ்க்க முடியும்.

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

async function* fetchCategories() {
  const categories = ['Electronics', 'Books', 'Clothing'];
  for (const category of categories) {
    await new Promise(resolve => setTimeout(resolve, 50));
    // Yielding an async iterator for products within this category
    yield fetchProductsForCategory(category);
  }
}

// A helper function to create a flatten combinator (conceptual)
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--- All Products (Flattened) ---');
  for await (const product of allProductsFlattenedIterator) {
    console.log(`Product: ${product.name}, Price: ${product.price}`);
  }
}

displayFlattenedProducts();

            

              
                Copy
              
            
          

இது படிநிலை அல்லது நெஸ்ட் செய்யப்பட்ட ஒத்திசைவற்ற தரவு கட்டமைப்புகளைக் கையாள்வதற்கு மிகவும் சக்தி வாய்ந்தது, இது வெவ்வேறு தொழில்கள் மற்றும் பிராந்தியங்களில் உள்ள சிக்கலான தரவு மாதிரிகளில் பொதுவானது.

காம்பினேட்டர்களை செயல்படுத்துதல் மற்றும் பயன்படுத்துதல்

மேலே காட்டப்பட்டுள்ள கருத்தியல் காம்பினேட்டர்கள் தர்க்கத்தை விளக்குகின்றன. நடைமுறையில், நீங்கள் வழக்கமாகப் பயன்படுத்துவீர்கள்:

• நூலகங்கள்: ixjs (Interactive JavaScript) அல்லது rxjs (அசிங்க் இட்டரேட்டர்களிலிருந்து அப்சர்வேபிள்களை உருவாக்க அதன் `from` ஆபரேட்டருடன்) போன்ற நூலகங்கள் ഇവற்றையும் மற்றும் பல காம்பினேட்டர்களையும் வலுவான செயலாக்கங்களாக வழங்குகின்றன.
• தனிப்பயன் செயலாக்கங்கள்: குறிப்பிட்ட தேவைகளுக்காக அல்லது கற்றல் நோக்கங்களுக்காக, காட்டப்பட்டுள்ளபடி உங்கள் சொந்த அசிங்க் ஜெனரேட்டர் செயல்பாடுகளை நீங்கள் செயல்படுத்தலாம்.

காம்பினேட்டர்களைச் சங்கிலிப்படுத்துதல்: உண்மையான சக்தி இந்த காம்பினேட்டர்களை ஒன்றாகச் சங்கிலிப்படுத்துவதில் இருந்து வருகிறது:

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

// This chain first maps users to add a fullName, then filters out the first user,
// and finally takes the first 3 of the remaining users.

            

              
                Copy
              
            
          

இந்த அறிவிப்பு அணுகுமுறை சிக்கலான ஒத்திசைவற்ற தரவு பைப்லைன்களைப் படிக்கக்கூடியதாகவும் நிர்வகிக்கக்கூடியதாகவும் ஆக்குகிறது, இது விநியோகிக்கப்பட்ட அமைப்புகளில் பணிபுரியும் சர்வதேச அணிகளுக்கு விலைமதிப்பற்றது.

உலகளாவிய மேம்பாட்டிற்கான நன்மைகள்

அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களை ஏற்றுக்கொள்வது உலகெங்கிலும் உள்ள டெவலப்பர்களுக்கு குறிப்பிடத்தக்க நன்மைகளை வழங்குகிறது:

• செயல்திறன் மேம்படுத்தல்: தரவு ஸ்ட்ரீம்களை பகுதி பகுதியாகச் செயலாக்குவதன் மூலமும், தேவையற்ற இடையகத்தைத் தவிர்ப்பதன் மூலமும், காம்பினேட்டர்கள் நினைவகத்தை திறமையாக நிர்வகிக்க உதவுகின்றன, இது பல்வேறு நெட்வொர்க் நிலைமைகள் மற்றும் வன்பொருள் திறன்களில் பயன்படுத்தப்படும் பயன்பாடுகளுக்கு முக்கியமானது.
• குறியீடு வாசிப்புத்திறன் மற்றும் பராமரிப்புத்திறன்: தொகுக்கக்கூடிய செயல்பாடுகள் தூய்மையான, மேலும் புரிந்துகொள்ளக்கூடிய குறியீட்டிற்கு வழிவகுக்கும். உலகளாவிய அணிகளுக்கு இது இன்றியமையாதது, அங்கு குறியீட்டின் தெளிவு ஒத்துழைப்பை எளிதாக்குகிறது மற்றும் புதியவர்களை உள்வாங்கும் நேரத்தைக் குறைக்கிறது.
• அளவிடுதல்: பொதுவான ஸ்ட்ரீம் செயல்பாடுகளைச் சுருக்கமாகக் கூறுவது, தரவு அளவு அல்லது சிக்கலான தன்மை அதிகரிக்கும்போது பயன்பாடுகள் மேலும் நேர்த்தியாக அளவிட அனுமதிக்கிறது.
• ஒத்திசைவின் சுருக்கம்: காம்பினேட்டர்கள் ஒத்திசைவற்ற செயல்பாடுகளைக் கையாள்வதற்கான உயர்-நிலை API-ஐ வழங்குகின்றன, இது குறைந்த-நிலை ப்ராமிஸ் நிர்வாகத்தில் சிக்கிக்கொள்ளாமல் தரவு ஓட்டத்தைப் பற்றி பகுத்தறிவதை எளிதாக்குகிறது.
• நிலைத்தன்மை: ஒரு நிலையான காம்பினேட்டர்களின் தொகுப்பைப் பயன்படுத்துவது, புவியியல் இருப்பிடத்தைப் பொருட்படுத்தாமல், வெவ்வேறு தொகுதிகள் மற்றும் அணிகள் முழுவதும் தரவு செயலாக்கத்திற்கு ஒரு நிலையான அணுகுமுறையை உறுதி செய்கிறது.
• பிழை கையாளுதல்: நன்கு வடிவமைக்கப்பட்ட காம்பினேட்டர் நூலகங்கள் பெரும்பாலும் வலுவான பிழை கையாளுதல் வழிமுறைகளைக் கொண்டுள்ளன, அவை ஸ்ட்ரீம் பைப்லைன் வழியாக பிழைகளை நேர்த்தியாகப் பரப்புகின்றன.

மேம்பட்ட பரிசீலனைகள் மற்றும் வடிவங்கள்

நீங்கள் அசிங்க் இட்டரேட்டர் காம்பினேட்டர்களுடன் மேலும் வசதியாகும்போது, இந்த மேம்பட்ட தலைப்புகளைக் கருத்தில் கொள்ளுங்கள்:

• பின்னழுத்த மேலாண்மை: ஒரு தயாரிப்பாளர் ஒரு நுகர்வோர் செயலாக்கக்கூடியதை விட வேகமாக தரவை வெளியிடும் சூழ்நிலைகளில், அதிநவீன காம்பினேட்டர்கள் நுகர்வோரை மூழ்கடிப்பதில் இருந்து தடுக்க பின்னழுத்த வழிமுறைகளைச் செயல்படுத்தலாம். இது அதிக அளவிலான உலகளாவிய தரவு ஊட்டங்களைச் செயலாக்கும் நிகழ்நேர அமைப்புகளுக்கு இன்றியமையாதது.
• பிழை கையாளுதல் உத்திகள்: பிழைகள் எவ்வாறு கையாளப்பட வேண்டும் என்பதை முடிவு செய்யுங்கள்: ஒரு பிழை முழு ஸ்ட்ரீமையும் நிறுத்த வேண்டுமா, அல்லது அது பிடிக்கப்பட்டு ஒரு குறிப்பிட்ட பிழையைக் கொண்டு செல்லும் மதிப்பாக மாற்றப்பட வேண்டுமா? காம்பினேட்டர்களை உள்ளமைக்கக்கூடிய பிழை கொள்கைகளுடன் வடிவமைக்கலாம்.
• சோம்பேறி மதிப்பீடு: பெரும்பாலான காம்பினேட்டர்கள் சோம்பேறித்தனமாக செயல்படுகின்றன, அதாவது நுகர்வு லூப் மூலம் கோரப்படும்போது மட்டுமே தரவு பெறப்பட்டு செயலாக்கப்படுகிறது. இது செயல்திறனுக்கு முக்கியமாகும்.
• தனிப்பயன் காம்பினேட்டர்களை உருவாக்குதல்: உங்கள் பயன்பாட்டின் களத்திற்குள் உள்ள தனித்துவமான சிக்கல்களைத் தீர்க்க உங்கள் சொந்த சிறப்பு காம்பினேட்டர்களை எவ்வாறு உருவாக்குவது என்பதைப் புரிந்து கொள்ளுங்கள்.

முடிவுரை

ஜாவாஸ்கிரிப்ட் அசிங்க் இட்டரேட்டர்கள் மற்றும் அவற்றின் காம்பினேட்டர்கள் ஒத்திசைவற்ற தரவைக் கையாள்வதில் ஒரு சக்திவாய்ந்த முன்னுதாரண மாற்றத்தைக் குறிக்கின்றன. உலகெங்கிலும் உள்ள டெவலப்பர்களுக்கு, இந்த கருவிகளில் தேர்ச்சி பெறுவது நேர்த்தியான குறியீட்டை எழுதுவது மட்டுமல்ல; இது பெருகிய முறையில் தரவு-தீவிர உலகில் செயல்திறன், அளவிடக்கூடிய மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளை உருவாக்குவது பற்றியது. ஒரு ஃபங்ஷனல் மற்றும் தொகுக்கக்கூடிய அணுகுமுறையை ஏற்றுக்கொள்வதன் மூலம், நீங்கள் சிக்கலான ஒத்திசைவற்ற தரவு பைப்லைன்களை தெளிவான, நிர்வகிக்கக்கூடிய மற்றும் திறமையான செயல்பாடுகளாக மாற்றலாம்.

நீங்கள் உலகளாவிய சென்சார் தரவைச் செயலாக்குகிறீர்களா, சர்வதேச சந்தைகளிலிருந்து நிதி அறிக்கைகளைத் திரட்டுகிறீர்களா, அல்லது உலகளாவிய பார்வையாளர்களுக்காக பதிலளிக்கக்கூடிய பயனர் இடைமுகங்களை உருவாக்குகிறீர்களா என்பதைப் பொருட்படுத்தாமல், அசிங்க் இட்டரேட்டர் காம்பினேட்டர்கள் வெற்றிக்கான கட்டுமானத் தொகுதிகளை வழங்குகின்றன. ixjs போன்ற நூலகங்களை ஆராயுங்கள், தனிப்பயன் செயலாக்கங்களுடன் பரிசோதனை செய்யுங்கள், மற்றும் நவீன உலகளாவிய மென்பொருள் மேம்பாட்டின் சவால்களைச் சந்திக்க உங்கள் ஒத்திசைவற்ற புரோகிராமிங் திறன்களை உயர்த்துங்கள்.