വെബ് സ്ട്രീംസ് API: ജാവാസ്ക്രിപ്റ്റിലെ കാര്യക്ഷമമായ ഡാറ്റാ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ

വെബ് സ്ട്രീംസ് API, ജാവാസ്ക്രിപ്റ്റിൽ സ്ട്രീമിംഗ് ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ഒരു ശക്തമായ സംവിധാനം നൽകുന്നു, ഇത് കാര്യക്ഷമവും പ്രതികരണശേഷിയുള്ളതുമായ വെബ് ആപ്ലിക്കേഷനുകൾ സാധ്യമാക്കുന്നു. മുഴുവൻ ഡാറ്റാസെറ്റുകളും ഒരേസമയം മെമ്മറിയിലേക്ക് ലോഡ് ചെയ്യുന്നതിനുപകരം, ഡാറ്റ ഘട്ടം ഘട്ടമായി പ്രോസസ്സ് ചെയ്യാൻ സ്ട്രീമുകൾ നിങ്ങളെ അനുവദിക്കുന്നു, ഇത് മെമ്മറി ഉപഭോഗം കുറയ്ക്കുകയും പ്രകടനം മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു. വലിയ ഫയലുകൾ, നെറ്റ്‌വർക്ക് അഭ്യർത്ഥനകൾ, അല്ലെങ്കിൽ തത്സമയ ഡാറ്റാ ഫീഡുകൾ എന്നിവ കൈകാര്യം ചെയ്യുമ്പോൾ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്.

എന്താണ് വെബ് സ്ട്രീമുകൾ?

അടിസ്ഥാനപരമായി, വെബ് സ്ട്രീംസ് API മൂന്ന് പ്രധാന തരം സ്ട്രീമുകൾ നൽകുന്നു:

• റീഡബിൾസ്ട്രീം (ReadableStream): ഒരു ഫയൽ, നെറ്റ്‌വർക്ക് കണക്ഷൻ, അല്ലെങ്കിൽ ജനറേറ്റുചെയ്ത ഡാറ്റ പോലുള്ള ഒരു ഡാറ്റാ ഉറവിടത്തെ പ്രതിനിധീകരിക്കുന്നു.
• റൈറ്റബിൾസ്ട്രീം (WritableStream): ഒരു ഫയൽ, നെറ്റ്‌വർക്ക് കണക്ഷൻ, അല്ലെങ്കിൽ ഒരു ഡാറ്റാബേസ് പോലുള്ള ഡാറ്റയുടെ ലക്ഷ്യസ്ഥാനത്തെ പ്രതിനിധീകരിക്കുന്നു.
• ട്രാൻസ്ഫോംസ്ട്രീം (TransformStream): ഒരു റീഡബിൾസ്ട്രീമിനും റൈറ്റബിൾസ്ട്രീമിനും ഇടയിലുള്ള ഒരു രൂപാന്തരീകരണ പൈപ്പ്ലൈനിനെ പ്രതിനിധീകരിക്കുന്നു. സ്ട്രീമിലൂടെ ഡാറ്റ കടന്നുപോകുമ്പോൾ അതിനെ പരിഷ്കരിക്കാനോ പ്രോസസ്സ് ചെയ്യാനോ ഇതിന് കഴിയും.

കാര്യക്ഷമമായ ഡാറ്റാ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ സൃഷ്ടിക്കുന്നതിന് ഈ സ്ട്രീം തരങ്ങൾ ഒരുമിച്ച് പ്രവർത്തിക്കുന്നു. ഡാറ്റ ഒരു റീഡബിൾസ്ട്രീമിൽ നിന്ന്, ഓപ്ഷണൽ ട്രാൻസ്ഫോംസ്ട്രീമുകളിലൂടെ, ഒടുവിൽ ഒരു റൈറ്റബിൾസ്ട്രീമിലേക്ക് ഒഴുകുന്നു.

പ്രധാന ആശയങ്ങളും പദങ്ങളും

• ചങ്കുകൾ (Chunks): ചങ്കുകൾ എന്ന് വിളിക്കുന്ന പ്രത്യേക യൂണിറ്റുകളായാണ് ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നത്. ഒരു ചങ്ക്, സ്ട്രിംഗ്, നമ്പർ, അല്ലെങ്കിൽ ഒബ്ജക്റ്റ് പോലുള്ള ഏതൊരു ജാവാസ്ക്രിപ്റ്റ് മൂല്യവുമാകാം.
• കൺട്രോളറുകൾ (Controllers): ഓരോ സ്ട്രീം തരത്തിനും സ്ട്രീം നിയന്ത്രിക്കുന്നതിനുള്ള മെത്തേഡുകൾ നൽകുന്ന ഒരു കൺട്രോളർ ഒബ്ജക്റ്റ് ഉണ്ട്. ഉദാഹരണത്തിന്, റീഡബിൾസ്ട്രീംകൺട്രോളർ നിങ്ങളെ സ്ട്രീമിലേക്ക് ഡാറ്റ ചേർക്കാൻ (enqueue) അനുവദിക്കുന്നു, അതേസമയം റൈറ്റബിൾസ്ട്രീംകൺട്രോളർ വരുന്ന ചങ്കുകൾ കൈകാര്യം ചെയ്യാൻ അനുവദിക്കുന്നു.
• പൈപ്പുകൾ (Pipes): സ്ട്രീമുകളെ പരസ്പരം ബന്ധിപ്പിക്കാൻ pipeTo(), pipeThrough() എന്നീ മെത്തേഡുകൾ ഉപയോഗിക്കാം. pipeTo() ഒരു റീഡബിൾസ്ട്രീമിനെ റൈറ്റബിൾസ്ട്രീമുമായി ബന്ധിപ്പിക്കുന്നു, അതേസമയം pipeThrough() ഒരു റീഡബിൾസ്ട്രീമിനെ ഒരു ട്രാൻസ്ഫോംസ്ട്രീമുമായും തുടർന്ന് ഒരു റൈറ്റബിൾസ്ട്രീമുമായും ബന്ധിപ്പിക്കുന്നു.
• ബാക്ക്പ്രഷർ (Backpressure): കൂടുതൽ ഡാറ്റ സ്വീകരിക്കാൻ തയ്യാറല്ലെന്ന് ഒരു ഉപഭോക്താവിന് (consumer) നിർമ്മാതാവിന് (producer) സൂചന നൽകാൻ അനുവദിക്കുന്ന ഒരു സംവിധാനം. ഇത് ഉപഭോക്താവിന് അമിതഭാരം ഉണ്ടാകുന്നത് തടയുകയും സുസ്ഥിരമായ നിരക്കിൽ ഡാറ്റ പ്രോസസ്സ് ചെയ്യുന്നുവെന്ന് ഉറപ്പാക്കുകയും ചെയ്യുന്നു.

ഒരു റീഡബിൾസ്ട്രീം നിർമ്മിക്കുന്നു

ReadableStream() കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു റീഡബിൾസ്ട്രീം നിർമ്മിക്കാൻ കഴിയും. കൺസ്ട്രക്റ്റർ ഒരു ഒബ്ജക്റ്റ് ആർഗ്യുമെന്റായി എടുക്കുന്നു, ഇത് സ്ട്രീമിന്റെ സ്വഭാവം നിയന്ത്രിക്കുന്നതിന് നിരവധി മെത്തേഡുകൾ നിർവചിക്കാൻ ഉപയോഗിക്കാം. ഇവയിൽ ഏറ്റവും പ്രധാനം start() മെത്തേഡ് ആണ്, ഇത് സ്ട്രീം നിർമ്മിക്കുമ്പോൾ വിളിക്കപ്പെടുന്നു, കൂടാതെ pull() മെത്തേഡ്, സ്ട്രീമിന് കൂടുതൽ ഡാറ്റ ആവശ്യമുള്ളപ്പോൾ വിളിക്കപ്പെടുന്നു.

സംഖ്യകളുടെ ഒരു ശ്രേണി ജനറേറ്റുചെയ്യുന്ന ഒരു റീഡബിൾസ്ട്രീം നിർമ്മിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

const readableStream = new ReadableStream({
  start(controller) {
    let counter = 0;

    function push() {
      if (counter >= 10) {
        controller.close();
        return;
      }

      controller.enqueue(counter++);
      setTimeout(push, 100);
    }

    push();
  },
});

ഈ ഉദാഹരണത്തിൽ, start() മെത്തേഡ് ഒരു കൗണ്ടർ ആരംഭിക്കുകയും സ്ട്രീമിലേക്ക് ഒരു നമ്പർ ചേർക്കുകയും (enqueue) തുടർന്ന് ഒരു ചെറിയ ഇടവേളയ്ക്ക് ശേഷം വീണ്ടും സ്വയം വിളിക്കുകയും ചെയ്യുന്ന ഒരു push() ഫംഗ്ഷൻ നിർവചിക്കുന്നു. കൗണ്ടർ 10-ൽ എത്തുമ്പോൾ controller.close() മെത്തേഡ് വിളിക്കപ്പെടുന്നു, ഇത് സ്ട്രീം പൂർത്തിയായെന്ന് സൂചിപ്പിക്കുന്നു.

ഒരു റീഡബിൾസ്ട്രീം ഉപയോഗിക്കുന്നു

ഒരു റീഡബിൾസ്ട്രീമിൽ നിന്ന് ഡാറ്റ ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾക്ക് ഒരു ReadableStreamDefaultReader ഉപയോഗിക്കാം. സ്ട്രീമിൽ നിന്ന് ചങ്കുകൾ വായിക്കുന്നതിനുള്ള മെത്തേഡുകൾ റീഡർ നൽകുന്നു. ഇതിൽ ഏറ്റവും പ്രധാനപ്പെട്ടത് read() മെത്തേഡ് ആണ്, ഇത് ഡാറ്റയുടെ ചങ്കും സ്ട്രീം പൂർത്തിയായിട്ടുണ്ടോ എന്ന് സൂചിപ്പിക്കുന്ന ഒരു ഫ്ലാഗും അടങ്ങിയ ഒരു ഒബ്ജക്റ്റുമായി റിസോൾവ് ആവുന്ന ഒരു പ്രോമിസ് നൽകുന്നു.

മുമ്പത്തെ ഉദാഹരണത്തിൽ നിർമ്മിച്ച റീഡബിൾസ്ട്രീമിൽ നിന്ന് ഡാറ്റ ഉപയോഗിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

const reader = readableStream.getReader();

async function read() {
  const { done, value } = await reader.read();

  if (done) {
    console.log('Stream complete');
    return;
  }

  console.log('Received:', value);
  read();
}

read();

ഈ ഉദാഹരണത്തിൽ, read() ഫംഗ്ഷൻ സ്ട്രീമിൽ നിന്ന് ഒരു ചങ്ക് വായിക്കുകയും അത് കൺസോളിൽ ലോഗ് ചെയ്യുകയും സ്ട്രീം പൂർത്തിയാകുന്നതുവരെ സ്വയം വീണ്ടും വിളിക്കുകയും ചെയ്യുന്നു.

ഒരു റൈറ്റബിൾസ്ട്രീം നിർമ്മിക്കുന്നു

WritableStream() കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു റൈറ്റബിൾസ്ട്രീം നിർമ്മിക്കാൻ കഴിയും. കൺസ്ട്രക്റ്റർ ഒരു ഒബ്ജക്റ്റ് ആർഗ്യുമെന്റായി എടുക്കുന്നു, ഇത് സ്ട്രീമിന്റെ സ്വഭാവം നിയന്ത്രിക്കുന്നതിന് നിരവധി മെത്തേഡുകൾ നിർവചിക്കാൻ ഉപയോഗിക്കാം. ഇതിൽ ഏറ്റവും പ്രധാനപ്പെട്ടവ write() മെത്തേഡ് (ഡാറ്റയുടെ ഒരു ചങ്ക് എഴുതാൻ തയ്യാറാകുമ്പോൾ വിളിക്കപ്പെടുന്നു), close() മെത്തേഡ് (സ്ട്രീം അടയ്ക്കുമ്പോൾ വിളിക്കപ്പെടുന്നു), abort() മെത്തേഡ് (സ്ട്രീം റദ്ദാക്കുമ്പോൾ വിളിക്കപ്പെടുന്നു) എന്നിവയാണ്.

ഓരോ ഡാറ്റാ ചങ്കും കൺസോളിലേക്ക് ലോഗ് ചെയ്യുന്ന ഒരു റൈറ്റബിൾസ്ട്രീം നിർമ്മിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

const writableStream = new WritableStream({
  write(chunk) {
    console.log('Writing:', chunk);
    return Promise.resolve(); // വിജയം സൂചിപ്പിക്കുന്നു
  },
  close() {
    console.log('Stream closed');
  },
  abort(err) {
    console.error('Stream aborted:', err);
  },
});

ഈ ഉദാഹരണത്തിൽ, write() മെത്തേഡ് ചങ്ക് കൺസോളിലേക്ക് ലോഗ് ചെയ്യുകയും ചങ്ക് വിജയകരമായി എഴുതിക്കഴിയുമ്പോൾ റിസോൾവ് ആവുന്ന ഒരു പ്രോമിസ് നൽകുകയും ചെയ്യുന്നു. സ്ട്രീം അടയ്ക്കുകയോ റദ്ദാക്കുകയോ ചെയ്യുമ്പോൾ close(), abort() മെത്തേഡുകൾ കൺസോളിലേക്ക് സന്ദേശങ്ങൾ ലോഗ് ചെയ്യുന്നു.

ഒരു റൈറ്റബിൾസ്ട്രീമിലേക്ക് എഴുതുന്നു

ഒരു റൈറ്റബിൾസ്ട്രീമിലേക്ക് ഡാറ്റ എഴുതാൻ, നിങ്ങൾക്ക് ഒരു WritableStreamDefaultWriter ഉപയോഗിക്കാം. സ്ട്രീമിലേക്ക് ചങ്കുകൾ എഴുതാനുള്ള മെത്തേഡുകൾ റൈറ്റർ നൽകുന്നു. ഇതിൽ ഏറ്റവും പ്രധാനപ്പെട്ടത് write() മെത്തേഡ് ആണ്, ഇത് ഡാറ്റയുടെ ഒരു ചങ്ക് ആർഗ്യുമെന്റായി എടുക്കുകയും ചങ്ക് വിജയകരമായി എഴുതിക്കഴിയുമ്പോൾ റിസോൾവ് ആവുന്ന ഒരു പ്രോമിസ് നൽകുകയും ചെയ്യുന്നു.

മുമ്പത്തെ ഉദാഹരണത്തിൽ നിർമ്മിച്ച റൈറ്റബിൾസ്ട്രീമിലേക്ക് ഡാറ്റ എഴുതുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

const writer = writableStream.getWriter();

async function writeData() {
  await writer.write('Hello, world!');
  await writer.close();
}

writeData();

ഈ ഉദാഹരണത്തിൽ, writeData() ഫംഗ്ഷൻ "Hello, world!" എന്ന സ്ട്രിംഗ് സ്ട്രീമിലേക്ക് എഴുതുകയും തുടർന്ന് സ്ട്രീം അടയ്ക്കുകയും ചെയ്യുന്നു.

ഒരു ട്രാൻസ്ഫോംസ്ട്രീം നിർമ്മിക്കുന്നു

TransformStream() കൺസ്ട്രക്റ്റർ ഉപയോഗിച്ച് നിങ്ങൾക്ക് ഒരു ട്രാൻസ്ഫോംസ്ട്രീം നിർമ്മിക്കാൻ കഴിയും. കൺസ്ട്രക്റ്റർ ഒരു ഒബ്ജക്റ്റ് ആർഗ്യുമെന്റായി എടുക്കുന്നു, ഇത് സ്ട്രീമിന്റെ സ്വഭാവം നിയന്ത്രിക്കുന്നതിന് നിരവധി മെത്തേഡുകൾ നിർവചിക്കാൻ ഉപയോഗിക്കാം. ഇതിൽ ഏറ്റവും പ്രധാനപ്പെട്ടവ transform() മെത്തേഡ് (ഡാറ്റയുടെ ഒരു ചങ്ക് രൂപാന്തരപ്പെടുത്താൻ തയ്യാറാകുമ്പോൾ വിളിക്കപ്പെടുന്നു), flush() മെത്തേഡ് (സ്ട്രീം അടയ്ക്കുമ്പോൾ വിളിക്കപ്പെടുന്നു) എന്നിവയാണ്.

ഡാറ്റയുടെ ഓരോ ചങ്കും വലിയക്ഷരത്തിലേക്ക് മാറ്റുന്ന ഒരു ട്രാൻസ്ഫോംസ്ട്രീം നിർമ്മിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

const transformStream = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toUpperCase());
  },
  flush(controller) {
    // ഓപ്ഷണൽ: സ്ട്രീം അടയ്ക്കുമ്പോൾ എന്തെങ്കിലും അന്തിമ പ്രവർത്തനങ്ങൾ നടത്തുക
  },
});

ഈ ഉദാഹരണത്തിൽ, transform() മെത്തേഡ് ചങ്കിനെ വലിയക്ഷരത്തിലേക്ക് മാറ്റി കൺട്രോളറിന്റെ ക്യൂവിലേക്ക് ചേർക്കുന്നു. flush() മെത്തേഡ് സ്ട്രീം അടയ്ക്കുമ്പോൾ വിളിക്കപ്പെടുന്നു, ഇത് ഏതെങ്കിലും അന്തിമ പ്രവർത്തനങ്ങൾ നടത്താൻ ഉപയോഗിക്കാം.

പൈപ്പ്ലൈനുകളിൽ ട്രാൻസ്ഫോംസ്ട്രീമുകൾ ഉപയോഗിക്കുന്നു

ഡാറ്റാ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ സൃഷ്ടിക്കുന്നതിന് ട്രാൻസ്ഫോംസ്ട്രീമുകൾ ഒരുമിച്ച് ബന്ധിപ്പിക്കുമ്പോൾ ഏറ്റവും ഉപയോഗപ്രദമാണ്. ഒരു റീഡബിൾസ്ട്രീമിനെ ഒരു ട്രാൻസ്ഫോംസ്ട്രീമുമായും തുടർന്ന് ഒരു റൈറ്റബിൾസ്ട്രീമുമായും ബന്ധിപ്പിക്കുന്നതിന് നിങ്ങൾക്ക് pipeThrough() മെത്തേഡ് ഉപയോഗിക്കാം.

ഒരു റീഡബിൾസ്ട്രീമിൽ നിന്ന് ഡാറ്റ വായിക്കുകയും, ഒരു ട്രാൻസ്ഫോംസ്ട്രീം ഉപയോഗിച്ച് അത് വലിയക്ഷരത്തിലേക്ക് മാറ്റുകയും, തുടർന്ന് അത് ഒരു റൈറ്റബിൾസ്ട്രീമിലേക്ക് എഴുതുകയും ചെയ്യുന്ന ഒരു പൈപ്പ്ലൈൻ നിർമ്മിക്കുന്നതിനുള്ള ഒരു ഉദാഹരണം ഇതാ:

const readableStream = new ReadableStream({
  start(controller) {
    controller.enqueue('hello');
    controller.enqueue('world');
    controller.close();
  },
});

const transformStream = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toUpperCase());
  },
});

const writableStream = new WritableStream({
  write(chunk) {
    console.log('Writing:', chunk);
    return Promise.resolve();
  },
});

readableStream.pipeThrough(transformStream).pipeTo(writableStream);

ഈ ഉദാഹരണത്തിൽ, pipeThrough() മെത്തേഡ് readableStream-നെ transformStream-മായി ബന്ധിപ്പിക്കുന്നു, തുടർന്ന് pipeTo() മെത്തേഡ് transformStream-നെ writableStream-മായി ബന്ധിപ്പിക്കുന്നു. ഡാറ്റ റീഡബിൾസ്ട്രീമിൽ നിന്ന് ട്രാൻസ്ഫോംസ്ട്രീമിലൂടെ (അവിടെ അത് വലിയക്ഷരത്തിലേക്ക് മാറ്റപ്പെടുന്നു) ഒഴുകി, ഒടുവിൽ റൈറ്റബിൾസ്ട്രീമിൽ (അവിടെ അത് കൺസോളിലേക്ക് ലോഗ് ചെയ്യപ്പെടുന്നു) എത്തുന്നു.

ബാക്ക്പ്രഷർ

വേഗതയേറിയ ഒരു നിർമ്മാതാവ് (producer) വേഗത കുറഞ്ഞ ഒരു ഉപഭോക്താവിനെ (consumer) ബുദ്ധിമുട്ടിക്കുന്നത് തടയുന്ന വെബ് സ്ട്രീമുകളിലെ ഒരു നിർണായക സംവിധാനമാണ് ബാക്ക്പ്രഷർ. ഉത്പാദിപ്പിക്കുന്ന ഡാറ്റയുടെ നിരക്കിനൊപ്പം ഉപഭോക്താവിന് മുന്നോട്ട് പോകാൻ കഴിയാതെ വരുമ്പോൾ, വേഗത കുറയ്ക്കാൻ നിർമ്മാതാവിന് സൂചന നൽകാൻ കഴിയും. ഇത് സ്ട്രീമിന്റെ കൺട്രോളർ, റീഡർ/റൈറ്റർ ഒബ്ജക്റ്റുകൾ വഴിയാണ് സാധ്യമാക്കുന്നത്.

ഒരു റീഡബിൾസ്ട്രീമിന്റെ ആന്തരിക ക്യൂ നിറയുമ്പോൾ, ക്യൂവിൽ സ്ഥലം ലഭ്യമാകുന്നതുവരെ pull() മെത്തേഡ് വിളിക്കപ്പെടില്ല. അതുപോലെ, ഒരു റൈറ്റബിൾസ്ട്രീമിന്റെ write() മെത്തേഡിന്, കൂടുതൽ ഡാറ്റ സ്വീകരിക്കാൻ സ്ട്രീം തയ്യാറാകുമ്പോൾ മാത്രം റിസോൾവ് ആവുന്ന ഒരു പ്രോമിസ് നൽകാൻ കഴിയും.

ബാക്ക്പ്രഷർ ശരിയായി കൈകാര്യം ചെയ്യുന്നതിലൂടെ, വ്യത്യസ്ത ഡാറ്റാ നിരക്കുകൾ കൈകാര്യം ചെയ്യുമ്പോഴും നിങ്ങളുടെ ഡാറ്റാ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ കരുത്തുറ്റതും കാര്യക്ഷമവുമാണെന്ന് ഉറപ്പാക്കാൻ കഴിയും.

ഉപയോഗ സാഹചര്യങ്ങളും ഉദാഹരണങ്ങളും

1. വലിയ ഫയലുകൾ പ്രോസസ്സ് ചെയ്യുന്നു

വലിയ ഫയലുകൾ പൂർണ്ണമായി മെമ്മറിയിലേക്ക് ലോഡ് ചെയ്യാതെ പ്രോസസ്സ് ചെയ്യുന്നതിന് വെബ് സ്ട്രീംസ് API അനുയോജ്യമാണ്. നിങ്ങൾക്ക് ഫയൽ ചങ്കുകളായി വായിക്കാനും ഓരോ ചങ്കും പ്രോസസ്സ് ചെയ്യാനും ഫലങ്ങൾ മറ്റൊരു ഫയലിലേക്കോ സ്ട്രീമിലേക്കോ എഴുതാനും കഴിയും.

async function processFile(inputFile, outputFile) {
  const readableStream = fs.createReadStream(inputFile).pipeThrough(new TextDecoderStream());
  const writableStream = fs.createWriteStream(outputFile).pipeThrough(new TextEncoderStream());

  const transformStream = new TransformStream({
    transform(chunk, controller) {
      // ഉദാഹരണം: ഓരോ വരിയും വലിയക്ഷരത്തിലേക്ക് മാറ്റുന്നു
      const lines = chunk.split('\n');
      lines.forEach(line => controller.enqueue(line.toUpperCase() + '\n'));
    }
  });

  await readableStream.pipeThrough(transformStream).pipeTo(writableStream);
  console.log('File processing complete!');
}

// ഉപയോഗ ഉദാഹരണം (Node.js ആവശ്യമാണ്)
// const fs = require('fs');
// processFile('input.txt', 'output.txt');

2. നെറ്റ്‌വർക്ക് അഭ്യർത്ഥനകൾ കൈകാര്യം ചെയ്യുന്നു

API പ്രതികരണങ്ങൾ അല്ലെങ്കിൽ സെർവർ-സെൻറ് ഇവന്റുകൾ പോലുള്ള നെറ്റ്‌വർക്ക് അഭ്യർത്ഥനകളിൽ നിന്ന് ലഭിക്കുന്ന ഡാറ്റ പ്രോസസ്സ് ചെയ്യാൻ നിങ്ങൾക്ക് വെബ് സ്ട്രീംസ് API ഉപയോഗിക്കാം. ഇത് മുഴുവൻ പ്രതികരണവും ഡൗൺലോഡ് ചെയ്യുന്നതിനായി കാത്തിരിക്കുന്നതിനുപകരം, ഡാറ്റ എത്തുമ്പോൾ തന്നെ പ്രോസസ്സ് ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

async function fetchAndProcessData(url) {
  const response = await fetch(url);
  const reader = response.body.getReader();
  const decoder = new TextDecoder();

  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        break;
      }
      const text = decoder.decode(value);
      // ലഭിച്ച ഡാറ്റ പ്രോസസ്സ് ചെയ്യുക
      console.log('Received:', text);
    }
  } catch (error) {
    console.error('Error reading from stream:', error);
  } finally {
    reader.releaseLock();
  }
}

// ഉപയോഗ ഉദാഹരണം
// fetchAndProcessData('https://example.com/api/data');

3. തത്സമയ ഡാറ്റാ ഫീഡുകൾ

ഓഹരി വിലകൾ അല്ലെങ്കിൽ സെൻസർ റീഡിംഗുകൾ പോലുള്ള തത്സമയ ഡാറ്റാ ഫീഡുകൾ കൈകാര്യം ചെയ്യുന്നതിനും വെബ് സ്ട്രീമുകൾ അനുയോജ്യമാണ്. നിങ്ങൾക്ക് ഒരു റീഡബിൾസ്ട്രീമിനെ ഒരു ഡാറ്റാ ഉറവിടവുമായി ബന്ധിപ്പിക്കുകയും വരുന്ന ഡാറ്റ എത്തുമ്പോൾ തന്നെ പ്രോസസ്സ് ചെയ്യുകയും ചെയ്യാം.

// ഉദാഹരണം: ഒരു തത്സമയ ഡാറ്റാ ഫീഡ് അനുകരിക്കുന്നു
const readableStream = new ReadableStream({
  start(controller) {
    let intervalId = setInterval(() => {
      const data = Math.random(); // സെൻസർ റീഡിംഗ് അനുകരിക്കുന്നു
      controller.enqueue(`Data: ${data.toFixed(2)}`);
    }, 1000);

    this.cancel = () => {
      clearInterval(intervalId);
      controller.close();
    };
  },
  cancel() {
    this.cancel();
  }
});

const reader = readableStream.getReader();

async function readStream() {
  try {
    while (true) {
      const { done, value } = await reader.read();
      if (done) {
        console.log('Stream closed.');
        break;
      }
      console.log('Received:', value);
    }
  } catch (error) {
    console.error('Error reading from stream:', error);
  } finally {
    reader.releaseLock();
  }
}

readStream();

// 10 സെക്കൻഡിന് ശേഷം സ്ട്രീം നിർത്തുക
setTimeout(() => {readableStream.cancel()}, 10000);

വെബ് സ്ട്രീംസ് API ഉപയോഗിക്കുന്നതിന്റെ പ്രയോജനങ്ങൾ

• മെച്ചപ്പെട്ട പ്രകടനം: ഡാറ്റ ഘട്ടം ഘട്ടമായി പ്രോസസ്സ് ചെയ്യുക, മെമ്മറി ഉപഭോഗം കുറയ്ക്കുകയും പ്രതികരണശേഷി മെച്ചപ്പെടുത്തുകയും ചെയ്യുന്നു.
• മെച്ചപ്പെട്ട മെമ്മറി മാനേജ്മെന്റ്: മുഴുവൻ ഡാറ്റാസെറ്റുകളും മെമ്മറിയിലേക്ക് ലോഡ് ചെയ്യുന്നത് ഒഴിവാക്കുക, പ്രത്യേകിച്ച് വലിയ ഫയലുകൾക്കോ നെറ്റ്‌വർക്ക് സ്ട്രീമുകൾക്കോ ഇത് ഉപയോഗപ്രദമാണ്.
• മികച്ച ഉപയോക്തൃ അനുഭവം: ഡാറ്റ നേരത്തെ പ്രോസസ്സ് ചെയ്യാനും പ്രദർശിപ്പിക്കാനും തുടങ്ങുക, ഇത് കൂടുതൽ സംവേദനാത്മകവും പ്രതികരണശേഷിയുള്ളതുമായ ഉപയോക്തൃ അനുഭവം നൽകുന്നു.
• ലളിതമായ ഡാറ്റാ പ്രോസസ്സിംഗ്: ട്രാൻസ്ഫോംസ്ട്രീമുകൾ ഉപയോഗിച്ച് മോഡുലാർ, പുനരുപയോഗിക്കാവുന്ന ഡാറ്റാ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ നിർമ്മിക്കുക.
• ബാക്ക്പ്രഷർ പിന്തുണ: വ്യത്യസ്ത ഡാറ്റാ നിരക്കുകൾ കൈകാര്യം ചെയ്യുകയും ഉപഭോക്താക്കൾക്ക് അമിതഭാരം ഉണ്ടാകുന്നത് തടയുകയും ചെയ്യുക.

പരിഗണനകളും മികച്ച രീതികളും

• പിശകുകൾ കൈകാര്യം ചെയ്യൽ: സ്ട്രീം പിശകുകൾ ഭംഗിയായി കൈകാര്യം ചെയ്യാനും അപ്രതീക്ഷിതമായ ആപ്ലിക്കേഷൻ തകരാറുകൾ തടയാനും ശക്തമായ പിശക് കൈകാര്യം ചെയ്യൽ സംവിധാനം നടപ്പിലാക്കുക.
• വിഭവങ്ങളുടെ മാനേജ്മെന്റ്: മെമ്മറി ചോർച്ച ഒഴിവാക്കാൻ സ്ട്രീമുകൾക്ക് ഇനി ആവശ്യമില്ലാത്തപ്പോൾ വിഭവങ്ങൾ ശരിയായി റിലീസ് ചെയ്യുക. reader.releaseLock() ഉപയോഗിക്കുക, സ്ട്രീമുകൾ ഉചിതമായ സമയത്ത് അടയ്ക്കുകയോ റദ്ദാക്കുകയോ ചെയ്തിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക.
• എൻകോഡിംഗും ഡീകോഡിംഗും: ശരിയായ ക്യാരക്ടർ എൻകോഡിംഗ് ഉറപ്പാക്കാൻ ടെക്സ്റ്റ് അടിസ്ഥാനമാക്കിയുള്ള ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിന് TextEncoderStream, TextDecoderStream എന്നിവ ഉപയോഗിക്കുക.
• ബ്രൗസർ അനുയോജ്യത: വെബ് സ്ട്രീംസ് API ഉപയോഗിക്കുന്നതിന് മുമ്പ് ബ്രൗസർ അനുയോജ്യത പരിശോധിക്കുക, പഴയ ബ്രൗസറുകൾക്കായി പോളിഫില്ലുകൾ ഉപയോഗിക്കുന്നത് പരിഗണിക്കുക.
• പരിശോധന: നിങ്ങളുടെ ഡാറ്റാ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ വിവിധ സാഹചര്യങ്ങളിൽ ശരിയായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാൻ സമഗ്രമായി പരിശോധിക്കുക.

ഉപസംഹാരം

ജാവാസ്ക്രിപ്റ്റിൽ സ്ട്രീമിംഗ് ഡാറ്റ കൈകാര്യം ചെയ്യുന്നതിനുള്ള ശക്തവും കാര്യക്ഷമവുമായ ഒരു മാർഗ്ഗം വെബ് സ്ട്രീംസ് API നൽകുന്നു. പ്രധാന ആശയങ്ങൾ മനസിലാക്കുകയും വിവിധ സ്ട്രീം തരങ്ങൾ ഉപയോഗിക്കുകയും ചെയ്യുന്നതിലൂടെ, നിങ്ങൾക്ക് വലിയ ഫയലുകൾ, നെറ്റ്‌വർക്ക് അഭ്യർത്ഥനകൾ, തത്സമയ ഡാറ്റാ ഫീഡുകൾ എന്നിവ എളുപ്പത്തിൽ കൈകാര്യം ചെയ്യാൻ കഴിയുന്ന കരുത്തുറ്റതും പ്രതികരണശേഷിയുള്ളതുമായ വെബ് ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ കഴിയും. ബാക്ക്പ്രഷർ നടപ്പിലാക്കുകയും പിശകുകൾ കൈകാര്യം ചെയ്യുന്നതിനും വിഭവങ്ങളുടെ മാനേജ്മെന്റിനുമുള്ള മികച്ച രീതികൾ പിന്തുടരുകയും ചെയ്യുന്നത് നിങ്ങളുടെ ഡാറ്റാ പ്രോസസ്സിംഗ് പൈപ്പ്ലൈനുകൾ വിശ്വസനീയവും മികച്ച പ്രകടനമുള്ളതുമാണെന്ന് ഉറപ്പാക്കും. വെബ് ആപ്ലിക്കേഷനുകൾ വികസിക്കുകയും കൂടുതൽ സങ്കീർണ്ണമായ ഡാറ്റ കൈകാര്യം ചെയ്യുകയും ചെയ്യുന്നതനുസരിച്ച്, വെബ് സ്ട്രീംസ് API ലോകമെമ്പാടുമുള്ള ഡെവലപ്പർമാർക്ക് ഒരു അത്യാവശ്യ ഉപകരണമായി മാറും.