Web Streams API: ஜாவாஸ்கிரிப்டில் திறமையான தரவு செயலாக்க பைப்லைன்கள்

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

Web Streams என்றால் என்ன?

அதன் மையத்தில், Web Streams API மூன்று முக்கிய வகை ஸ்ட்ரீம்களை வழங்குகிறது:

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

இந்த ஸ்ட்ரீம் வகைகள் திறமையான தரவு செயலாக்கப் பைப்லைன்களை உருவாக்க ஒன்றிணைந்து செயல்படுகின்றன. தரவு ஒரு ReadableStream-இலிருந்து, விருப்பமான TransformStreams வழியாக, இறுதியாக ஒரு WritableStream-க்கு பாய்கிறது.

முக்கிய கருத்துக்கள் மற்றும் சொற்களஞ்சியம்

• Chunks: தரவு துண்டுகள் (chunks) எனப்படும் தனித்தனி அலகுகளில் செயலாக்கப்படுகிறது. ஒரு துண்டு என்பது ஸ்டிரிங், எண் அல்லது ஆப்ஜெக்ட் போன்ற எந்த ஜாவாஸ்கிரிப்ட் மதிப்பாகவும் இருக்கலாம்.
• Controllers: ஒவ்வொரு ஸ்ட்ரீம் வகைக்கும் ஒரு தொடர்புடைய கண்ட்ரோலர் ஆப்ஜெக்ட் உள்ளது, இது ஸ்ட்ரீமை நிர்வகிப்பதற்கான முறைகளை வழங்குகிறது. எடுத்துக்காட்டாக, ReadableStreamController ஸ்ட்ரீமில் தரவை வரிசைப்படுத்த உங்களை அனுமதிக்கிறது, அதேசமயம் WritableStreamController உள்வரும் துண்டுகளைக் கையாள உங்களை அனுமதிக்கிறது.
• Pipes: ஸ்ட்ரீம்களை pipeTo() மற்றும் pipeThrough() முறைகளைப் பயன்படுத்தி ஒன்றாக இணைக்கலாம். pipeTo() ஒரு ReadableStream-ஐ WritableStream-உடன் இணைக்கிறது, அதேசமயம் pipeThrough() ஒரு ReadableStream-ஐ TransformStream-உடனும், பின்னர் ஒரு WritableStream-உடனும் இணைக்கிறது.
• Backpressure: இது ஒரு நுகர்வோர், உற்பத்தியாளரிடம் அதிக தரவைப் பெறத் தயாராக இல்லை என்பதைக் குறிக்க அனுமதிக்கும் ஒரு பொறிமுறையாகும். இது நுகர்வோர் அதிகச்சுமைக்கு உள்ளாவதைத் தடுக்கிறது மற்றும் தரவு ஒரு நிலையான விகிதத்தில் செயலாக்கப்படுவதை உறுதி செய்கிறது.

ஒரு ReadableStream-ஐ உருவாக்குதல்

ReadableStream() கன்ஸ்ட்ரக்டரைப் பயன்படுத்தி நீங்கள் ஒரு ReadableStream-ஐ உருவாக்கலாம். கன்ஸ்ட்ரக்டர் ஒரு ஆப்ஜெக்டை ஒரு வாதமாக எடுத்துக்கொள்கிறது, இது ஸ்ட்ரீமின் நடத்தையைக் கட்டுப்படுத்த பல முறைகளை வரையறுக்கலாம். இவற்றில் மிக முக்கியமானது start() முறை, இது ஸ்ட்ரீம் உருவாக்கப்படும்போது அழைக்கப்படுகிறது, மற்றும் pull() முறை, இது ஸ்ட்ரீமிற்கு அதிக தரவு தேவைப்படும்போது அழைக்கப்படுகிறது.

எண்களின் வரிசையை உருவாக்கும் ஒரு ReadableStream-ஐ உருவாக்குவதற்கான எடுத்துக்காட்டு இங்கே:

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() முறை ஒரு கவுண்டரைத் துவக்கி, push() செயல்பாட்டை வரையறுக்கிறது, இது ஸ்ட்ரீமில் ஒரு எண்ணை வரிசைப்படுத்தி, பின்னர் ஒரு சிறிய தாமதத்திற்குப் பிறகு மீண்டும் தன்னை அழைக்கிறது. கவுண்டர் 10-ஐ அடையும் போது controller.close() முறை அழைக்கப்படுகிறது, இது ஸ்ட்ரீம் முடிந்துவிட்டது என்பதைக் குறிக்கிறது.

ஒரு ReadableStream-ஐப் பயன்படுத்துதல்

ஒரு ReadableStream-இலிருந்து தரவைப் பயன்படுத்த, நீங்கள் ஒரு ReadableStreamDefaultReader-ஐப் பயன்படுத்தலாம். ரீடர் ஸ்ட்ரீமிலிருந்து துண்டுகளைப் படிப்பதற்கான முறைகளை வழங்குகிறது. இவற்றில் மிக முக்கியமானது read() முறை, இது ஒரு வாக்குறுதியைத் தருகிறது, அது தரவின் துண்டு மற்றும் ஸ்ட்ரீம் முடிந்துவிட்டதா என்பதைக் குறிக்கும் ஒரு கொடியைக் கொண்ட ஒரு ஆப்ஜெக்ட்டுடன் தீர்க்கிறது.

முந்தைய எடுத்துக்காட்டில் உருவாக்கப்பட்ட ReadableStream-இலிருந்து தரவைப் பயன்படுத்துவதற்கான எடுத்துக்காட்டு இங்கே:

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-ஐ உருவாக்குதல்

WritableStream() கன்ஸ்ட்ரக்டரைப் பயன்படுத்தி நீங்கள் ஒரு WritableStream-ஐ உருவாக்கலாம். கன்ஸ்ட்ரக்டர் ஒரு ஆப்ஜெக்டை ஒரு வாதமாக எடுத்துக்கொள்கிறது, இது ஸ்ட்ரீமின் நடத்தையைக் கட்டுப்படுத்த பல முறைகளை வரையறுக்கலாம். இவற்றில் மிக முக்கியமானவை write() முறை, இது தரவின் ஒரு துண்டு எழுதத் தயாராக இருக்கும்போது அழைக்கப்படுகிறது, close() முறை, இது ஸ்ட்ரீம் மூடப்படும்போது அழைக்கப்படுகிறது, மற்றும் abort() முறை, இது ஸ்ட்ரீம் நிறுத்தப்படும்போது அழைக்கப்படுகிறது.

தரவின் ஒவ்வொரு துண்டையும் கன்சோலில் பதிவுசெய்யும் ஒரு WritableStream-ஐ உருவாக்குவதற்கான எடுத்துக்காட்டு இங்கே:

const writableStream = new WritableStream({
  write(chunk) {
    console.log('Writing:', chunk);
    return Promise.resolve(); // Indicate success
  },
  close() {
    console.log('Stream closed');
  },
  abort(err) {
    console.error('Stream aborted:', err);
  },
});

இந்த எடுத்துக்காட்டில், write() முறை துண்டைக் கன்சோலில் பதிவுசெய்து, துண்டு வெற்றிகரமாக எழுதப்பட்டதும் தீர்க்கப்படும் ஒரு வாக்குறுதியைத் தருகிறது. close() மற்றும் abort() முறைகள் ஸ்ட்ரீம் மூடப்படும்போது அல்லது நிறுத்தப்படும்போது முறையே கன்சோலில் செய்திகளைப் பதிவு செய்கின்றன.

ஒரு WritableStream-இல் எழுதுதல்

ஒரு WritableStream-க்கு தரவை எழுத, நீங்கள் ஒரு WritableStreamDefaultWriter-ஐப் பயன்படுத்தலாம். ரைட்டர் ஸ்ட்ரீமிற்கு துண்டுகளை எழுதுவதற்கான முறைகளை வழங்குகிறது. இவற்றில் மிக முக்கியமானது write() முறை, இது தரவின் ஒரு துண்டை வாதமாக எடுத்துக்கொள்கிறது மற்றும் துண்டு வெற்றிகரமாக எழுதப்பட்டதும் தீர்க்கப்படும் ஒரு வாக்குறுதியைத் தருகிறது.

முந்தைய எடுத்துக்காட்டில் உருவாக்கப்பட்ட WritableStream-க்கு தரவை எழுதுவதற்கான எடுத்துக்காட்டு இங்கே:

const writer = writableStream.getWriter();

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

writeData();

இந்த எடுத்துக்காட்டில், writeData() செயல்பாடு "Hello, world!" என்ற ஸ்டிரிங்கை ஸ்ட்ரீமிற்கு எழுதி, பின்னர் ஸ்ட்ரீமை மூடுகிறது.

ஒரு TransformStream-ஐ உருவாக்குதல்

TransformStream() கன்ஸ்ட்ரக்டரைப் பயன்படுத்தி நீங்கள் ஒரு TransformStream-ஐ உருவாக்கலாம். கன்ஸ்ட்ரக்டர் ஒரு ஆப்ஜெக்டை ஒரு வாதமாக எடுத்துக்கொள்கிறது, இது ஸ்ட்ரீமின் நடத்தையைக் கட்டுப்படுத்த பல முறைகளை வரையறுக்கலாம். இவற்றில் மிக முக்கியமானது transform() முறை, இது தரவின் ஒரு துண்டு மாற்றப்படத் தயாராக இருக்கும்போது அழைக்கப்படுகிறது, மற்றும் flush() முறை, இது ஸ்ட்ரீம் மூடப்படும்போது அழைக்கப்படுகிறது.

தரவின் ஒவ்வொரு துண்டையும் பெரிய எழுத்துக்களாக மாற்றும் ஒரு TransformStream-ஐ உருவாக்குவதற்கான எடுத்துக்காட்டு இங்கே:

const transformStream = new TransformStream({
  transform(chunk, controller) {
    controller.enqueue(chunk.toUpperCase());
  },
  flush(controller) {
    // Optional: Perform any final operations when the stream is closing
  },
});

இந்த எடுத்துக்காட்டில், transform() முறை துண்டைப் பெரிய எழுத்துக்களாக மாற்றி, அதை கண்ட்ரோலரின் வரிசையில் சேர்க்கிறது. flush() முறை ஸ்ட்ரீம் மூடப்படும்போது அழைக்கப்படுகிறது மற்றும் எந்த இறுதிச் செயல்களையும் செய்யப் பயன்படுத்தப்படலாம்.

பைப்லைன்களில் TransformStreams-ஐப் பயன்படுத்துதல்

TransformStreams தரவு செயலாக்கப் பைப்லைன்களை உருவாக்க ஒன்றாக இணைக்கப்படும்போது மிகவும் பயனுள்ளதாக இருக்கும். ஒரு ReadableStream-ஐ ஒரு TransformStream-உடனும், பின்னர் ஒரு WritableStream-உடனும் இணைக்க pipeThrough() முறையைப் பயன்படுத்தலாம்.

ஒரு ReadableStream-இலிருந்து தரவைப் படித்து, அதை ஒரு TransformStream-ஐப் பயன்படுத்தி பெரிய எழுத்துக்களாக மாற்றி, பின்னர் அதை ஒரு WritableStream-இல் எழுதும் ஒரு பைப்லைனை உருவாக்குவதற்கான எடுத்துக்காட்டு இங்கே:

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-உடன் இணைக்கிறது. தரவு ReadableStream-இலிருந்து, TransformStream வழியாக (அங்கு அது பெரிய எழுத்துக்களாக மாற்றப்படுகிறது), பின்னர் WritableStream-க்கு (அங்கு அது கன்சோலில் பதிவு செய்யப்படுகிறது) பாய்கிறது.

பின்அழுத்தம் (Backpressure)

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

ஒரு ReadableStream-இன் உள் வரிசை நிரம்பியிருக்கும் போது, வரிசையில் இடம் கிடைக்கும் வரை pull() முறை அழைக்கப்படாது. இதேபோல், ஒரு WritableStream-இன் write() முறை, ஸ்ட்ரீம் அதிக தரவை ஏற்கத் தயாராக இருக்கும்போது மட்டுமே தீர்க்கப்படும் ஒரு வாக்குறுதியைத் தரலாம்.

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

பயன்பாட்டு நிகழ்வுகள் மற்றும் எடுத்துக்காட்டுகள்

1. பெரிய கோப்புகளைச் செயலாக்குதல்

Web Streams 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) {
      // Example: Convert each line to uppercase
      const lines = chunk.split('\n');
      lines.forEach(line => controller.enqueue(line.toUpperCase() + '\n'));
    }
  });

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

// Example Usage (Node.js required)
// const fs = require('fs');
// processFile('input.txt', 'output.txt');

2. நெட்வொர்க் கோரிக்கைகளைக் கையாளுதல்

API பதில்கள் அல்லது சேவையகத்தால் அனுப்பப்பட்ட நிகழ்வுகள் போன்ற நெட்வொர்க் கோரிக்கைகளிலிருந்து பெறப்பட்ட தரவைச் செயலாக்க Web Streams 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);
      // Process the received data
      console.log('Received:', text);
    }
  } catch (error) {
    console.error('Error reading from stream:', error);
  } finally {
    reader.releaseLock();
  }
}

// Example Usage
// fetchAndProcessData('https://example.com/api/data');

3. நிகழ்நேர தரவு ஊட்டங்கள்

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

// Example: Simulating a real-time data feed
const readableStream = new ReadableStream({
  start(controller) {
    let intervalId = setInterval(() => {
      const data = Math.random(); // Simulate sensor reading
      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();

// Stop the stream after 10 seconds
setTimeout(() => {readableStream.cancel()}, 10000);

Web Streams API-ஐப் பயன்படுத்துவதன் நன்மைகள்

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

கருத்தாய்வுகள் மற்றும் சிறந்த நடைமுறைகள்

• பிழை கையாளுதல்: ஸ்ட்ரீம் பிழைகளை அழகாகக் கையாளவும், எதிர்பாராத பயன்பாட்டு நடத்தையைத் தடுக்கவும் வலுவான பிழை கையாளுதலைச் செயல்படுத்தவும்.
• வள மேலாண்மை: நினைவகக் கசிவுகளைத் தவிர்க்க, ஸ்ட்ரீம்கள் இனி தேவைப்படாதபோது வளங்களைச் சரியாக விடுவிக்கவும். reader.releaseLock()-ஐப் பயன்படுத்தவும் மற்றும் ஸ்ட்ரீம்கள் பொருத்தமான போது மூடப்பட்டதா அல்லது நிறுத்தப்பட்டதா என்பதை உறுதிப்படுத்தவும்.
• குறியாக்கம் மற்றும் குறியீடு நீக்கம்: சரியான எழுத்துக் குறியாக்கத்தை உறுதிப்படுத்த, உரை அடிப்படையிலான தரவைக் கையாள TextEncoderStream மற்றும் TextDecoderStream-ஐப் பயன்படுத்தவும்.
• உலாவி இணக்கத்தன்மை: Web Streams API-ஐப் பயன்படுத்துவதற்கு முன்பு உலாவி இணக்கத்தன்மையை சரிபார்க்கவும், மேலும் பழைய உலாவிகளுக்கு பாலிஃபில்களைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளவும்.
• சோதனை: உங்கள் தரவு செயலாக்கப் பைப்லைன்கள் பல்வேறு நிலைமைகளின் கீழ் சரியாகச் செயல்படுவதை உறுதிசெய்ய அவற்றை முழுமையாகச் சோதிக்கவும்.

முடிவுரை

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