જાવાસ્ક્રિપ્ટ ઇટરેટર હેલ્પર સ્ટ્રીમ ઓપ્ટિમાઇઝેશન એન્જિન: સ્ટ્રીમ પ્રોસેસિંગમાં સુધારો

આધુનિક જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટમાં, કાર્યક્ષમ ડેટા પ્રોસેસિંગ સર્વોપરી છે. મોટા ડેટાસેટ્સ, જટિલ રૂપાંતરણો અને એસિંક્રોનસ ઓપરેશન્સને હેન્ડલ કરવા માટે મજબૂત અને ઓપ્ટિમાઇઝ્ડ સોલ્યુશન્સની જરૂર પડે છે. જાવાસ્ક્રિપ્ટ ઇટરેટર હેલ્પર સ્ટ્રીમ ઓપ્ટિમાઇઝેશન એન્જિન ઇટરેટર્સ, જનરેટર ફંક્શન્સ અને ફંક્શનલ પ્રોગ્રામિંગ પેરાડાઇમ્સની ક્ષમતાઓનો લાભ લઈને સ્ટ્રીમ પ્રોસેસિંગ માટે એક શક્તિશાળી અને લવચીક અભિગમ પૂરો પાડે છે. આ લેખ આ એન્જિનના મુખ્ય ખ્યાલો, ફાયદાઓ અને વ્યવહારુ એપ્લિકેશન્સની શોધ કરે છે, જે ડેવલપર્સને વધુ સ્વચ્છ, વધુ કાર્યક્ષમ અને જાળવી શકાય તેવો કોડ લખવામાં સક્ષમ બનાવે છે.

સ્ટ્રીમ શું છે?

સ્ટ્રીમ એ ડેટા એલિમેન્ટ્સનો ક્રમ છે જે સમય જતાં ઉપલબ્ધ થાય છે. પરંપરાગત એરેથી વિપરીત, જે તમામ ડેટાને એક જ સમયે મેમરીમાં રાખે છે, સ્ટ્રીમ્સ ડેટાને ટુકડાઓમાં અથવા વ્યક્તિગત એલિમેન્ટ્સ તરીકે પ્રોસેસ કરે છે જેમ જેમ તે આવે છે. આ અભિગમ ખાસ કરીને મોટા ડેટાસેટ્સ અથવા રિયલ-ટાઇમ ડેટા ફીડ્સ સાથે કામ કરતી વખતે ફાયદાકારક છે, જ્યાં સમગ્ર ડેટાસેટને એક જ સમયે પ્રોસેસ કરવું અવ્યવહારુ અથવા અશક્ય હશે. સ્ટ્રીમ્સ મર્યાદિત (એક નિર્ધારિત અંત સાથે) અથવા અનંત (સતત ડેટા ઉત્પન્ન કરતા) હોઈ શકે છે.

જાવાસ્ક્રિપ્ટમાં, સ્ટ્રીમ્સને ઇટરેટર્સ અને જનરેટર ફંક્શન્સનો ઉપયોગ કરીને રજૂ કરી શકાય છે, જે લેઝી ઇવેલ્યુએશન અને કાર્યક્ષમ મેમરી વપરાશ માટે પરવાનગી આપે છે. ઇટરેટર એ એક ઓબ્જેક્ટ છે જે એક ક્રમ અને તે ક્રમમાં આગલા એલિમેન્ટને એક્સેસ કરવાની પદ્ધતિને વ્યાખ્યાયિત કરે છે. ES6 માં રજૂ કરાયેલા જનરેટર ફંક્શન્સ, માંગ પર મૂલ્યો ઉત્પન્ન કરવા માટે yield કીવર્ડનો ઉપયોગ કરીને ઇટરેટર્સ બનાવવાની એક અનુકૂળ રીત પૂરી પાડે છે.

ઓપ્ટિમાઇઝેશનની જરૂરિયાત

જ્યારે ઇટરેટર્સ અને સ્ટ્રીમ્સ મેમરી કાર્યક્ષમતા અને લેઝી ઇવેલ્યુએશનના સંદર્ભમાં નોંધપાત્ર ફાયદાઓ પ્રદાન કરે છે, ત્યારે પણ બિનઅનુભવી અમલીકરણો પ્રદર્શનમાં અવરોધો તરફ દોરી શકે છે. ઉદાહરણ તરીકે, મોટા ડેટાસેટ પર વારંવાર ઇટરેટ કરવું અથવા દરેક એલિમેન્ટ પર જટિલ રૂપાંતરણો કરવા તે કમ્પ્યુટેશનલી ખર્ચાળ હોઈ શકે છે. આ તે સ્થાન છે જ્યાં સ્ટ્રીમ ઓપ્ટિમાઇઝેશન ભૂમિકા ભજવે છે.

સ્ટ્રીમ ઓપ્ટિમાઇઝેશનનો હેતુ સ્ટ્રીમ પ્રોસેસિંગ સાથે સંકળાયેલ ઓવરહેડને ઘટાડવાનો છે:

• બિનજરૂરી ઇટરેશન્સ ઘટાડવું: ઓપરેશન્સને બુદ્ધિપૂર્વક જોડીને અથવા શોર્ટ-સર્કિટ કરીને રીડન્ડન્ટ ગણતરીઓ ટાળવી.
• લેઝી ઇવેલ્યુએશનનો લાભ લેવો: પરિણામોની ખરેખર જરૂર ન પડે ત્યાં સુધી ગણતરીઓને મુલતવી રાખવી, જેનો ઉપયોગ ન થઈ શકે તેવા ડેટાની બિનજરૂરી પ્રોસેસિંગને અટકાવવી.
• ડેટા રૂપાંતરણોને ઓપ્ટિમાઇઝ કરવું: વિશિષ્ટ રૂપાંતરણો માટે સૌથી કાર્યક્ષમ અલ્ગોરિધમ્સ અને ડેટા સ્ટ્રક્ચર્સ પસંદ કરવા.
• ઓપરેશન્સને સમાંતર કરવું: થ્રુપુટ સુધારવા માટે પ્રોસેસિંગ વર્કલોડને બહુવિધ કોરો અથવા થ્રેડ્સમાં વિતરિત કરવું.

જાવાસ્ક્રિપ્ટ ઇટરેટર હેલ્પર સ્ટ્રીમ ઓપ્ટિમાઇઝેશન એન્જિનનો પરિચય

જાવાસ્ક્રિપ્ટ ઇટરેટર હેલ્પર સ્ટ્રીમ ઓપ્ટિમાઇઝેશન એન્જિન સ્ટ્રીમ પ્રોસેસિંગ વર્કફ્લોને ઓપ્ટિમાઇઝ કરવા માટે ટૂલ્સ અને તકનીકોનો સમૂહ પ્રદાન કરે છે. તેમાં સામાન્ય રીતે હેલ્પર ફંક્શન્સનો સંગ્રહ હોય છે જે ઇટરેટર્સ અને જનરેટર્સ પર કાર્ય કરે છે, જે ડેવલપર્સને ઘોષણાત્મક અને કાર્યક્ષમ રીતે ઓપરેશન્સને એકસાથે જોડવાની મંજૂરી આપે છે. આ હેલ્પર ફંક્શન્સમાં ઘણીવાર લેઝી ઇવેલ્યુએશન, શોર્ટ-સર્કિટિંગ અને ડેટા કેશિંગ જેવા ઓપ્ટિમાઇઝેશનનો સમાવેશ થાય છે જેથી પ્રોસેસિંગ ઓવરહેડને ઓછો કરી શકાય.

એન્જિનના મુખ્ય ઘટકોમાં સામાન્ય રીતે શામેલ હોય છે:

• ઇટરેટર હેલ્પર્સ: ફંક્શન્સ જે સામાન્ય સ્ટ્રીમ ઓપરેશન્સ જેમ કે મેપિંગ, ફિલ્ટરિંગ, રીડ્યુસિંગ અને ડેટા રૂપાંતરિત કરે છે.
• ઓપ્ટિમાઇઝેશન સ્ટ્રેટેજીસ: સ્ટ્રીમ ઓપરેશન્સના પ્રદર્શનને સુધારવા માટેની તકનીકો, જેમ કે લેઝી ઇવેલ્યુએશન, શોર્ટ-સર્કિટિંગ અને સમાંતરીકરણ.
• સ્ટ્રીમ એબ્સ્ટ્રેક્શન: એક ઉચ્ચ-સ્તરનું એબ્સ્ટ્રેક્શન જે સ્ટ્રીમ્સની રચના અને હેરફેરને સરળ બનાવે છે, ઇટરેટર્સ અને જનરેટર્સની જટિલતાઓને છુપાવે છે.

મુખ્ય ઇટરેટર હેલ્પર ફંક્શન્સ

નીચે કેટલાક સૌથી સામાન્ય રીતે ઉપયોગમાં લેવાતા ઇટરેટર હેલ્પર ફંક્શન્સ છે:

map

map ફંક્શન સ્ટ્રીમમાં દરેક એલિમેન્ટને આપેલ ફંક્શન લાગુ કરીને રૂપાંતરિત કરે છે. તે રૂપાંતરિત એલિમેન્ટ્સ ધરાવતો નવો સ્ટ્રીમ પરત કરે છે.

ઉદાહરણ: સંખ્યાઓના સ્ટ્રીમને તેમના વર્ગોમાં રૂપાંતરિત કરવું.

            
function* numbers() {
  yield 1;
  yield 2;
  yield 3;
}

function map(iterator, transform) {
  return {
    next() {
      const { value, done } = iterator.next();
      if (done) {
        return { value: undefined, done: true };
      }
      return { value: transform(value), done: false };
    },
    [Symbol.iterator]() {
      return this;
    },
  };
}

const squaredNumbers = map(numbers(), (x) => x * x);

for (const num of squaredNumbers) {
  console.log(num); // Output: 1, 4, 9
}

            

              
                Copy
              
            
          

filter

filter ફંક્શન સ્ટ્રીમમાંથી એવા એલિમેન્ટ્સ પસંદ કરે છે જે આપેલ શરતને સંતોષે છે. તે ફક્ત તે જ એલિમેન્ટ્સ ધરાવતો નવો સ્ટ્રીમ પરત કરે છે જે ફિલ્ટરમાંથી પસાર થાય છે.

ઉદાહરણ: સ્ટ્રીમમાંથી બેકી સંખ્યાઓને ફિલ્ટર કરવી.

            
function* numbers() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
}

function filter(iterator, predicate) {
  return {
    next() {
      while (true) {
        const { value, done } = iterator.next();
        if (done) {
          return { value: undefined, done: true };
        }
        if (predicate(value)) {
          return { value, done: false };
        }
      }
    },
    [Symbol.iterator]() {
      return this;
    },
  };
}

const evenNumbers = filter(numbers(), (x) => x % 2 === 0);

for (const num of evenNumbers) {
  console.log(num); // Output: 2, 4
}

            

              
                Copy
              
            
          

reduce

reduce ફંક્શન સ્ટ્રીમમાંના એલિમેન્ટ્સને દરેક એલિમેન્ટ અને એક એક્યુમ્યુલેટર પર રીડ્યુસર ફંક્શન લાગુ કરીને એક જ મૂલ્યમાં એકીકૃત કરે છે. તે અંતિમ સંચિત મૂલ્ય પરત કરે છે.

ઉદાહરણ: સ્ટ્રીમમાં સંખ્યાઓનો સરવાળો કરવો.

            
function* numbers() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
}

function reduce(iterator, reducer, initialValue) {
  let accumulator = initialValue;
  let next = iterator.next();
  while (!next.done) {
    accumulator = reducer(accumulator, next.value);
    next = iterator.next();
  }
  return accumulator;
}

const sum = reduce(numbers(), (acc, x) => acc + x, 0);

console.log(sum); // Output: 15

            

              
                Copy
              
            
          

find

find ફંક્શન સ્ટ્રીમમાં પ્રથમ એલિમેન્ટ પરત કરે છે જે આપેલ શરતને સંતોષે છે. તે મેળ ખાતું એલિમેન્ટ મળતાની સાથે જ ઇટરેટ કરવાનું બંધ કરે છે.

ઉદાહરણ: સ્ટ્રીમમાં પ્રથમ બેકી સંખ્યા શોધવી.

            
function* numbers() {
  yield 1;
  yield 3;
  yield 2;
  yield 4;
  yield 5;
}

function find(iterator, predicate) {
  let next = iterator.next();
  while (!next.done) {
    if (predicate(next.value)) {
      return next.value;
    }
    next = iterator.next();
  }
  return undefined;
}

const firstEvenNumber = find(numbers(), (x) => x % 2 === 0);

console.log(firstEvenNumber); // Output: 2

            

              
                Copy
              
            
          

forEach

forEach ફંક્શન સ્ટ્રીમમાં દરેક એલિમેન્ટ માટે એકવાર પ્રદાન કરેલ ફંક્શનને એક્ઝિક્યુટ કરે છે. તે નવો સ્ટ્રીમ પરત કરતું નથી અથવા મૂળ સ્ટ્રીમમાં ફેરફાર કરતું નથી.

ઉદાહરણ: સ્ટ્રીમમાં દરેક સંખ્યાને પ્રિન્ટ કરવી.

            
function* numbers() {
  yield 1;
  yield 2;
  yield 3;
}

function forEach(iterator, action) {
  let next = iterator.next();
  while (!next.done) {
    action(next.value);
    next = iterator.next();
  }
}

forEach(numbers(), (x) => console.log(x)); // Output: 1, 2, 3

            

              
                Copy
              
            
          

some

some ફંક્શન પરીક્ષણ કરે છે કે સ્ટ્રીમમાં ઓછામાં ઓછો એક એલિમેન્ટ આપેલ શરતને સંતોષે છે કે નહીં. જો કોઈ એલિમેન્ટ શરતને સંતોષે તો તે true પરત કરે છે, અન્યથા false પરત કરે છે. તે મેળ ખાતું એલિમેન્ટ મળતાની સાથે જ ઇટરેટ કરવાનું બંધ કરે છે.

ઉદાહરણ: સ્ટ્રીમમાં કોઈ બેકી સંખ્યા છે કે નહીં તે તપાસવું.

            
function* numbers() {
  yield 1;
  yield 3;
  yield 5;
  yield 2;
  yield 7;
}

function some(iterator, predicate) {
  let next = iterator.next();
  while (!next.done) {
    if (predicate(next.value)) {
      return true;
    }
    next = iterator.next();
  }
  return false;
}

const hasEvenNumber = some(numbers(), (x) => x % 2 === 0);

console.log(hasEvenNumber); // Output: true

            

              
                Copy
              
            
          

every

every ફંક્શન પરીક્ષણ કરે છે કે સ્ટ્રીમમાંના બધા એલિમેન્ટ્સ આપેલ શરતને સંતોષે છે કે નહીં. જો બધા એલિમેન્ટ્સ શરતને સંતોષે તો તે true પરત કરે છે, અન્યથા false પરત કરે છે. તે શરતને સંતોષતું ન હોય તેવું એલિમેન્ટ મળતાની સાથે જ ઇટરેટ કરવાનું બંધ કરે છે.

ઉદાહરણ: સ્ટ્રીમમાંની બધી સંખ્યાઓ પોઝિટિવ છે કે નહીં તે તપાસવું.

            
function* numbers() {
  yield 1;
  yield 3;
  yield 5;
  yield 7;
  yield 9;
}

function every(iterator, predicate) {
  let next = iterator.next();
  while (!next.done) {
    if (!predicate(next.value)) {
      return false;
    }
    next = iterator.next();
  }
  return true;
}

const allPositive = every(numbers(), (x) => x > 0);

console.log(allPositive); // Output: true

            

              
                Copy
              
            
          

flatMap

flatMap ફંક્શન સ્ટ્રીમમાં દરેક એલિમેન્ટને આપેલ ફંક્શન લાગુ કરીને રૂપાંતરિત કરે છે, અને પછી પરિણામી સ્ટ્રીમ્સના સ્ટ્રીમને એક જ સ્ટ્રીમમાં ફ્લેટ કરે છે. તે map પછી flat ને કોલ કરવા બરાબર છે.

ઉદાહરણ: વાક્યોના સ્ટ્રીમને શબ્દોના સ્ટ્રીમમાં રૂપાંતરિત કરવું.

            
function* sentences() {
  yield "This is a sentence.";
  yield "Another sentence here.";
}

function* words(sentence) {
  const wordList = sentence.split(' ');
  for (const word of wordList) {
    yield word;
  }
}

function flatMap(iterator, transform) {
  return {
    next() {
      if (!this.currentIterator) {
        const { value, done } = iterator.next();
        if (done) {
          return { value: undefined, done: true };
        }
        this.currentIterator = transform(value)[Symbol.iterator]();
      }

      const nextValue = this.currentIterator.next();
      if (nextValue.done) {
        this.currentIterator = undefined;
        return this.next(); // Recursively call next to get the next value from the outer iterator
      }
      return nextValue;
    },
    [Symbol.iterator]() {
      return this;
    },
  };
}

const allWords = flatMap(sentences(), words);

for (const word of allWords) {
  console.log(word); // Output: This, is, a, sentence., Another, sentence, here.
}

            

              
                Copy
              
            
          

take

take ફંક્શન મૂળ સ્ટ્રીમમાંથી પ્રથમ n એલિમેન્ટ્સ ધરાવતો નવો સ્ટ્રીમ પરત કરે છે.

ઉદાહરણ: સ્ટ્રીમમાંથી પ્રથમ 3 સંખ્યાઓ લેવી.

            
function* numbers() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
}

function take(iterator, n) {
  let count = 0;
  return {
    next() {
      if (count >= n) {
        return { value: undefined, done: true };
      }
      const { value, done } = iterator.next();
      if (done) {
        return { value: undefined, done: true };
      }
      count++;
      return { value, done: false };
    },
    [Symbol.iterator]() {
      return this;
    },
  };
}

const firstThree = take(numbers(), 3);

for (const num of firstThree) {
  console.log(num); // Output: 1, 2, 3
}

            

              
                Copy
              
            
          

drop

drop ફંક્શન મૂળ સ્ટ્રીમમાંથી પ્રથમ n એલિમેન્ટ્સ સિવાયના બધા એલિમેન્ટ્સ ધરાવતો નવો સ્ટ્રીમ પરત કરે છે.

ઉદાહરણ: સ્ટ્રીમમાંથી પ્રથમ 2 સંખ્યાઓ છોડવી.

            
function* numbers() {
  yield 1;
  yield 2;
  yield 3;
  yield 4;
  yield 5;
}

function drop(iterator, n) {
  let count = 0;
  while (count < n) {
    const { done } = iterator.next();
    if (done) {
      return {
        next() { return { value: undefined, done: true }; },
        [Symbol.iterator]() { return this; }
      };
    }
    count++;
  }
  return iterator;
}

const afterTwo = drop(numbers(), 2);

for (const num of afterTwo) {
  console.log(num); // Output: 3, 4, 5
}

            

              
                Copy
              
            
          

toArray

toArray ફંક્શન સ્ટ્રીમનો વપરાશ કરે છે અને સ્ટ્રીમમાંના બધા એલિમેન્ટ્સ ધરાવતો એરે પરત કરે છે.

ઉદાહરણ: સંખ્યાઓના સ્ટ્રીમને એરેમાં રૂપાંતરિત કરવું.

            
function* numbers() {
  yield 1;
  yield 2;
  yield 3;
}

function toArray(iterator) {
  const result = [];
  let next = iterator.next();
  while (!next.done) {
    result.push(next.value);
    next = iterator.next();
  }
  return result;
}

const numberArray = toArray(numbers());

console.log(numberArray); // Output: [1, 2, 3]

            

              
                Copy
              
            
          

ઓપ્ટિમાઇઝેશન સ્ટ્રેટેજીસ

લેઝી ઇવેલ્યુએશન

લેઝી ઇવેલ્યુએશન એ એક એવી તકનીક છે જે ગણતરીઓના અમલને ત્યાં સુધી મુલતવી રાખે છે જ્યાં સુધી તેમના પરિણામોની ખરેખર જરૂર ન પડે. આ તે ડેટાની બિનજરૂરી પ્રોસેસિંગને ટાળીને પ્રદર્શનમાં નોંધપાત્ર સુધારો કરી શકે છે જેનો કદાચ ઉપયોગ ન થાય. ઇટરેટર હેલ્પર ફંક્શન્સ સ્વાભાવિક રીતે લેઝી ઇવેલ્યુએશનને સપોર્ટ કરે છે કારણ કે તેઓ ઇટરેટર્સ પર કાર્ય કરે છે, જે માંગ પર મૂલ્યો ઉત્પન્ન કરે છે. જ્યારે બહુવિધ ઇટરેટર હેલ્પર ફંક્શન્સને એકસાથે જોડવામાં આવે છે, ત્યારે ગણતરીઓ ત્યારે જ કરવામાં આવે છે જ્યારે પરિણામી સ્ટ્રીમનો વપરાશ થાય છે, જેમ કે for...of લૂપ સાથે તેના પર ઇટરેટ કરતી વખતે અથવા toArray સાથે તેને એરેમાં રૂપાંતરિત કરતી વખતે.

ઉદાહરણ:

            
function* largeDataSet() {
  for (let i = 0; i < 1000000; i++) {
    yield i;
  }
}

const processedData = map(filter(largeDataSet(), (x) => x % 2 === 0), (x) => x * 2);

// No computations are performed until we iterate over processedData
let count = 0;
for (const num of processedData) {
  console.log(num);
  count++;
  if (count > 10) {
    break; // Only process the first 10 elements
  }
}

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, largeDataSet જનરેટર એક મિલિયન સંખ્યાઓ ઉત્પન્ન કરે છે. જોકે, map અને filter ઓપરેશન્સ ત્યાં સુધી કરવામાં આવતા નથી જ્યાં સુધી for...of લૂપ processedData સ્ટ્રીમ પર ઇટરેટ ન કરે. લૂપ ફક્ત પ્રથમ 10 એલિમેન્ટ્સને પ્રોસેસ કરે છે, તેથી ફક્ત પ્રથમ 10 બેકી સંખ્યાઓને રૂપાંતરિત કરવામાં આવે છે, બાકીના એલિમેન્ટ્સ માટે બિનજરૂરી ગણતરીઓને ટાળીને.

શોર્ટ-સર્કિટિંગ

શોર્ટ-સર્કિટિંગ એ એક એવી તકનીક છે જે પરિણામ જાણીતું થતાંની સાથે જ ગણતરીના અમલને અટકાવે છે. આ find, some, અને every જેવી ઓપરેશન્સ માટે ખાસ કરીને ઉપયોગી થઈ શકે છે, જ્યાં મેળ ખાતું એલિમેન્ટ મળ્યા પછી અથવા શરતનું ઉલ્લંઘન થયા પછી ઇટરેશનને વહેલું સમાપ્ત કરી શકાય છે.

ઉદાહરણ:

            
function* infiniteNumbers() {
  let i = 0;
  while (true) {
    yield i++;
  }
}

const hasValueGreaterThan1000 = some(infiniteNumbers(), (x) => x > 1000);

console.log(hasValueGreaterThan1000); // Output: true

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, infiniteNumbers જનરેટર સંખ્યાઓનો અનંત સ્ટ્રીમ ઉત્પન્ન કરે છે. જોકે, some ફંક્શન 1000 થી મોટી સંખ્યા મળતાની સાથે જ ઇટરેટ કરવાનું બંધ કરે છે, અનંત લૂપને ટાળીને.

ડેટા કેશિંગ

ડેટા કેશિંગ એ એક એવી તકનીક છે જે ગણતરીઓના પરિણામોને સંગ્રહિત કરે છે જેથી કરીને તેમને ફરીથી ગણતરી કર્યા વિના પાછળથી ફરીથી ઉપયોગમાં લઈ શકાય. આ તે સ્ટ્રીમ્સ માટે ઉપયોગી થઈ શકે છે જેનો બહુવિધ વખત વપરાશ થાય છે અથવા તે સ્ટ્રીમ્સ માટે જે કમ્પ્યુટેશનલી ખર્ચાળ એલિમેન્ટ્સ ધરાવે છે.

ઉદાહરણ:

            
function* expensiveComputations() {
  for (let i = 0; i < 5; i++) {
    console.log("Calculating value for", i); // This will only print once for each value
    yield i * i * i;
  }
}

function cachedStream(iterator) {
  const cache = [];
  let index = 0;
  return {
    next() {
      if (index < cache.length) {
        return { value: cache[index++], done: false };
      }
      const next = iterator.next();
      if (next.done) {
        return next;
      }
      cache.push(next.value);
      index++;
      return next;
    },
    [Symbol.iterator]() {
      return this;
    },
  };
}

const cachedData = cachedStream(expensiveComputations());

// First iteration
for (const num of cachedData) {
  console.log("First iteration:", num);
}

// Second iteration - values are retrieved from the cache
for (const num of cachedData) {
  console.log("Second iteration:", num);
}

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, expensiveComputations જનરેટર દરેક એલિમેન્ટ માટે કમ્પ્યુટેશનલી ખર્ચાળ ઓપરેશન કરે છે. cachedStream ફંક્શન આ ગણતરીઓના પરિણામોને કેશ કરે છે, જેથી તે ફક્ત એક જ વાર કરવાની જરૂર પડે. cachedData સ્ટ્રીમ પરનું બીજું ઇટરેશન કેશમાંથી મૂલ્યો પુનઃપ્રાપ્ત કરે છે, રીડન્ડન્ટ ગણતરીઓને ટાળીને.

વ્યવહારુ એપ્લિકેશન્સ

જાવાસ્ક્રિપ્ટ ઇટરેટર હેલ્પર સ્ટ્રીમ ઓપ્ટિમાઇઝેશન એન્જિનને વિશાળ શ્રેણીની વ્યવહારુ એપ્લિકેશન્સમાં લાગુ કરી શકાય છે, જેમાં શામેલ છે:

• ડેટા પ્રોસેસિંગ પાઇપલાઇન્સ: જટિલ ડેટા પ્રોસેસિંગ પાઇપલાઇન્સ બનાવવી જે વિવિધ સ્ત્રોતોમાંથી ડેટાને રૂપાંતરિત, ફિલ્ટર અને એકીકૃત કરે છે.
• રિયલ-ટાઇમ ડેટા સ્ટ્રીમ્સ: સેન્સર્સ, સોશિયલ મીડિયા ફીડ્સ અથવા નાણાકીય બજારોમાંથી રિયલ-ટાઇમ ડેટા સ્ટ્રીમ્સની પ્રોસેસિંગ.
• એસિંક્રોનસ ઓપરેશન્સ: API કોલ્સ અથવા ડેટાબેઝ ક્વેરીઝ જેવા એસિંક્રોનસ ઓપરેશન્સને નોન-બ્લોકિંગ અને કાર્યક્ષમ રીતે હેન્ડલ કરવું.
• મોટી ફાઇલ પ્રોસેસિંગ: મોટી ફાઇલોને ટુકડાઓમાં પ્રોસેસ કરવી, મેમરી સમસ્યાઓ ટાળવી અને પ્રદર્શન સુધારવું.
• યુઝર ઇન્ટરફેસ અપડેટ્સ: ડેટા ફેરફારોના આધારે યુઝર ઇન્ટરફેસને પ્રતિક્રિયાશીલ અને કાર્યક્ષમ રીતે અપડેટ કરવું.

ઉદાહરણ: ડેટા પ્રોસેસિંગ પાઇપલાઇન બનાવવી

એક દૃશ્યનો વિચાર કરો જ્યાં તમારે ગ્રાહક ડેટા ધરાવતી મોટી CSV ફાઇલ પ્રોસેસ કરવાની જરૂર છે. પાઇપલાઇનમાં આ હોવું જોઈએ:

1. CSV ફાઇલને ટુકડાઓમાં વાંચો.
2. દરેક ટુકડાને ઓબ્જેક્ટ્સના એરેમાં પાર્સ કરો.
3. 18 વર્ષથી ઓછી ઉંમરના ગ્રાહકોને ફિલ્ટર કરો.
4. બાકીના ગ્રાહકોને સરળ ડેટા સ્ટ્રક્ચરમાં મેપ કરો.
5. બાકીના ગ્રાહકોની સરેરાશ ઉંમરની ગણતરી કરો.

            
async function* readCsvFile(filePath, chunkSize) {
  const fileHandle = await fs.open(filePath, 'r');
  const stream = fileHandle.readableWebStream();
  const reader = stream.getReader();
  let decoder = new TextDecoder('utf-8');

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      yield decoder.decode(value);
    }
  } finally {
    fileHandle.close();
  }
}

function* parseCsvChunk(csvChunk) {
  const lines = csvChunk.split('\n');
  const headers = lines[0].split(',');
  for (let i = 1; i < lines.length; i++) {
    const values = lines[i].split(',');
    if (values.length !== headers.length) continue; // Skip incomplete lines
    const customer = {};
    for (let j = 0; j < headers.length; j++) {
      customer[headers[j]] = values[j];
    }
    yield customer;
  }
}


async function processCustomerData(filePath) {
  const customerStream = flatMap(readCsvFile(filePath, 1024 * 1024), parseCsvChunk);

  const validCustomers = filter(customerStream, (customer) => parseInt(customer.age) >= 18);

  const simplifiedCustomers = map(validCustomers, (customer) => ({
    name: customer.name,
    age: parseInt(customer.age),
    city: customer.city,
  }));

  let sum = 0;
  let count = 0;
  for await (const customer of simplifiedCustomers) {
    sum += customer.age;
    count++;
  }

  const averageAge = count > 0 ? sum / count : 0;

  console.log("Average age of adult customers:", averageAge);
}

// Example usage:
// Assuming you have a file named 'customers.csv'
// processCustomerData('customers.csv');

            

              
                Copy
              
            
          

આ ઉદાહરણ દર્શાવે છે કે ડેટા પ્રોસેસિંગ પાઇપલાઇન બનાવવા માટે ઇટરેટર હેલ્પર્સનો ઉપયોગ કેવી રીતે કરવો. readCsvFile ફંક્શન CSV ફાઇલને ટુકડાઓમાં વાંચે છે, parseCsvChunk ફંક્શન દરેક ટુકડાને ગ્રાહક ઓબ્જેક્ટ્સના એરેમાં પાર્સ કરે છે, filter ફંક્શન 18 વર્ષથી ઓછી ઉંમરના ગ્રાહકોને ફિલ્ટર કરે છે, map ફંક્શન બાકીના ગ્રાહકોને સરળ ડેટા સ્ટ્રક્ચરમાં મેપ કરે છે, અને અંતિમ લૂપ બાકીના ગ્રાહકોની સરેરાશ ઉંમરની ગણતરી કરે છે. ઇટરેટર હેલ્પર્સ અને લેઝી ઇવેલ્યુએશનનો લાભ લઈને, આ પાઇપલાઇન સમગ્ર ફાઇલને મેમરીમાં લોડ કર્યા વિના મોટી CSV ફાઇલોને કાર્યક્ષમ રીતે પ્રોસેસ કરી શકે છે.

એસિંક ઇટરેટર્સ

આધુનિક જાવાસ્ક્રિપ્ટ એસિંક્રોનસ ઇટરેટર્સ પણ રજૂ કરે છે. એસિંક્રોનસ ઇટરેટર્સ અને જનરેટર્સ તેમના સિંક્રોનસ સમકક્ષો જેવા જ છે પરંતુ ઇટરેશન પ્રક્રિયામાં એસિંક્રોનસ ઓપરેશન્સ માટે પરવાનગી આપે છે. API કોલ્સ અથવા ડેટાબેઝ ક્વેરીઝ જેવા એસિંક્રોનસ ડેટા સ્ત્રોતો સાથે કામ કરતી વખતે તે ખાસ કરીને ઉપયોગી છે.

એસિંક્રોનસ ઇટરેટર બનાવવા માટે, તમે async function* સિન્ટેક્સનો ઉપયોગ કરી શકો છો. yield કીવર્ડનો ઉપયોગ પ્રોમિસિસ ઉત્પન્ન કરવા માટે થઈ શકે છે, જે ઇટરેટર દ્વારા પરત કરવામાં આવે તે પહેલાં આપોઆપ રિઝોલ્વ થઈ જશે.

ઉદાહરણ:

            
async function* fetchUsers() {
  for (let i = 1; i <= 3; i++) {
    const response = await fetch(`https://jsonplaceholder.typicode.com/users/${i}`);
    const user = await response.json();
    yield user;
  }
}

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

// main();

            

              
                Copy
              
            
          

આ ઉદાહરણમાં, fetchUsers ફંક્શન રિમોટ API માંથી યુઝર ડેટા મેળવે છે. yield કીવર્ડનો ઉપયોગ પ્રોમિસિસ ઉત્પન્ન કરવા માટે થાય છે, જે ઇટરેટર દ્વારા પરત કરવામાં આવે તે પહેલાં આપોઆપ રિઝોલ્વ થાય છે. for await...of લૂપનો ઉપયોગ એસિંક્રોનસ ઇટરેટર પર ઇટરેટ કરવા માટે થાય છે, દરેક પ્રોમિસ રિઝોલ્વ થાય તેની રાહ જોયા પછી યુઝર ડેટા પ્રોસેસ કરે છે.

એસિંક ઇટરેટર હેલ્પર્સને પણ સ્ટ્રીમમાં એસિંક્રોનસ ઓપરેશન્સ હેન્ડલ કરવા માટે સમાન રીતે લાગુ કરી શકાય છે. ઉદાહરણ તરીકે, સ્ટ્રીમમાં દરેક એલિમેન્ટ પર એસિંક્રોનસ રૂપાંતરણ લાગુ કરવા માટે asyncMap ફંક્શન બનાવી શકાય છે.

નિષ્કર્ષ

જાવાસ્ક્રિપ્ટ ઇટરેટર હેલ્પર સ્ટ્રીમ ઓપ્ટિમાઇઝેશન એન્જિન સ્ટ્રીમ પ્રોસેસિંગ માટે એક શક્તિશાળી અને લવચીક અભિગમ પૂરો પાડે છે, જે ડેવલપર્સને વધુ સ્વચ્છ, વધુ કાર્યક્ષમ અને જાળવી શકાય તેવો કોડ લખવામાં સક્ષમ બનાવે છે. ઇટરેટર્સ, જનરેટર ફંક્શન્સ અને ફંક્શનલ પ્રોગ્રામિંગ પેરાડાઇમ્સની ક્ષમતાઓનો લાભ લઈને, આ એન્જિન ડેટા પ્રોસેસિંગ વર્કફ્લોની કાર્યક્ષમતામાં નોંધપાત્ર સુધારો કરી શકે છે. આ એન્જિનના મુખ્ય ખ્યાલો, ઓપ્ટિમાઇઝેશન સ્ટ્રેટેજીસ અને વ્યવહારુ એપ્લિકેશન્સને સમજીને, ડેવલપર્સ મોટા ડેટાસેટ્સ, રિયલ-ટાઇમ ડેટા સ્ટ્રીમ્સ અને એસિંક્રોનસ ઓપરેશન્સને હેન્ડલ કરવા માટે મજબૂત અને માપી શકાય તેવા સોલ્યુશન્સ બનાવી શકે છે. તમારી જાવાસ્ક્રિપ્ટ ડેવલપમેન્ટ પદ્ધતિઓને ઉન્નત કરવા અને તમારા પ્રોજેક્ટ્સમાં કાર્યક્ષમતાના નવા સ્તરોને અનલોક કરવા માટે આ પેરાડાઇમ શિફ્ટને અપનાવો.