ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಕ್ಷ ಡೇಟಾ ಸಂಸ್ಕರಣೆಗಾಗಿ ವೆಬ್ ಸ್ಟ್ರೀಮ್ಸ್ API ಅನ್ವೇಷಿಸಿ. ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆ ಮತ್ತು ಮೆಮೊರಿ ನಿರ್ವಹಣೆಗಾಗಿ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ರಚಿಸಲು, ರೂಪಾಂತರಿಸಲು ಮತ್ತು ಬಳಸುವುದನ್ನು ಕಲಿಯಿರಿ.
ವೆಬ್ ಸ್ಟ್ರೀಮ್ಸ್ API: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ದಕ್ಷ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ಗಳು
ವೆಬ್ ಸ್ಟ್ರೀಮ್ಸ್ API ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸ್ಟ್ರೀಮಿಂಗ್ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ವ್ಯವಸ್ಥೆಯನ್ನು ಒದಗಿಸುತ್ತದೆ, ಇದು ದಕ್ಷ ಮತ್ತು ಸ್ಪಂದನಾಶೀಲ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಸಕ್ರಿಯಗೊಳಿಸುತ್ತದೆ. ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಒಂದೇ ಬಾರಿಗೆ ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡುವ ಬದಲು, ಸ್ಟ್ರೀಮ್‌ಗಳು ನಿಮಗೆ ಡೇಟಾವನ್ನು ಹಂತ ಹಂತವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ಸುಧಾರಿಸುತ್ತದೆ. ದೊಡ್ಡ ಫೈಲ್‌ಗಳು, ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳು ಅಥವಾ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಫೀಡ್‌ಗಳೊಂದಿಗೆ ವ್ಯವಹರಿಸುವಾಗ ಇದು ವಿಶೇಷವಾಗಿ ಉಪಯುಕ್ತವಾಗಿದೆ.
ವೆಬ್ ಸ್ಟ್ರೀಮ್‌ಗಳು ಎಂದರೇನು?
ಮೂಲಭೂತವಾಗಿ, ವೆಬ್ ಸ್ಟ್ರೀಮ್ಸ್ API ಮೂರು ಮುಖ್ಯ ವಿಧದ ಸ್ಟ್ರೀಮ್‌ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ:
- ReadableStream: ಡೇಟಾದ ಮೂಲವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಫೈಲ್, ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕ, ಅಥವಾ ರಚಿತವಾದ ಡೇಟಾ.
- WritableStream: ಡೇಟಾದ ಗಮ್ಯಸ್ಥಾನವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ, ಉದಾಹರಣೆಗೆ ಫೈಲ್, ನೆಟ್‌ವರ್ಕ್ ಸಂಪರ್ಕ, ಅಥವಾ ಡೇಟಾಬೇಸ್.
- TransformStream: ReadableStream ಮತ್ತು WritableStream ನಡುವಿನ ರೂಪಾಂತರ ಪೈಪ್‌ಲೈನ್ ಅನ್ನು ಪ್ರತಿನಿधಿಸುತ್ತದೆ. ಸ್ಟ್ರೀಮ್ ಮೂಲಕ ಡೇಟಾ ಹರಿಯುವಾಗ ಅದನ್ನು ಮಾರ್ಪಡಿಸಬಹುದು ಅಥವಾ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು.
ಈ ಸ್ಟ್ರೀಮ್ ಪ್ರಕಾರಗಳು ದಕ್ಷ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ರಚಿಸಲು ಒಟ್ಟಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆ. ಡೇಟಾವು ReadableStream ನಿಂದ, ಐಚ್ಛಿಕ TransformStreams ಮೂಲಕ, ಮತ್ತು ಅಂತಿಮವಾಗಿ WritableStream ಗೆ ಹರಿಯುತ್ತದೆ.
ಪ್ರಮುಖ ಪರಿಕಲ್ಪನೆಗಳು ಮತ್ತು ಪರಿಭಾಷೆ
- 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(); // ಯಶಸ್ಸನ್ನು ಸೂಚಿಸಿ
},
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) {
// ಐಚ್ಛಿಕ: ಸ್ಟ್ರೀಮ್ ಮುಚ್ಚುವಾಗ ಯಾವುದೇ ಅಂತಿಮ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಿ
},
});
ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, transform() ವಿಧಾನವು ಚಂಕ್ ಅನ್ನು ದೊಡ್ಡಕ್ಷರಕ್ಕೆ ಪರಿವರ್ತಿಸುತ್ತದೆ ಮತ್ತು ಅದನ್ನು ನಿಯಂತ್ರಕದ ಕ್ಯೂಗೆ ಎನ್‌ಕ್ಯೂ ಮಾಡುತ್ತದೆ. flush() ವಿಧಾನವು ಸ್ಟ್ರೀಮ್ ಮುಚ್ಚುವಾಗ ಕರೆಯಲ್ಪಡುತ್ತದೆ ಮತ್ತು ಯಾವುದೇ ಅಂತಿಮ ಕಾರ್ಯಾಚರಣೆಗಳನ್ನು ಮಾಡಲು ಬಳಸಬಹುದು.
ಪೈಪ್‌ಲೈನ್‌ಗಳಲ್ಲಿ TransformStreams ಅನ್ನು ಬಳಸುವುದು
TransformStreams ಅನ್ನು ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ರಚಿಸಲು ಒಟ್ಟಿಗೆ ಜೋಡಿಸಿದಾಗ ಅತ್ಯಂತ ಉಪಯುಕ್ತವಾಗಿವೆ. ನೀವು pipeThrough() ವಿಧಾನವನ್ನು ಬಳಸಿ ReadableStream ಅನ್ನು TransformStream ಗೆ, ಮತ್ತು ನಂತರ WritableStream ಗೆ ಸಂಪರ್ಕಿಸಬಹುದು.
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 ಗೆ (ಅಲ್ಲಿ ಅದನ್ನು ಕನ್ಸೋಲ್‌ಗೆ ಲಾಗ್ ಮಾಡಲಾಗುತ್ತದೆ) ಹರಿಯುತ್ತದೆ.
ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್
ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ವೆಬ್ ಸ್ಟ್ರೀಮ್ಸ್‌ನಲ್ಲಿ ಒಂದು ನಿರ್ಣಾಯಕ ವ್ಯವಸ್ಥೆಯಾಗಿದ್ದು, ವೇಗದ ಉತ್ಪಾದಕನು ನಿಧಾನಗತಿಯ ಗ್ರಾಹಕನ ಮೇಲೆ ಹೊರೆ ಹಾಕುವುದನ್ನು ತಡೆಯುತ್ತದೆ. ಗ್ರಾಹಕನು ಡೇಟಾ ಉತ್ಪಾದನೆಯ ದರಕ್ಕೆ ಸರಿಸಾಟಿಯಾಗಿರಲು ಸಾಧ್ಯವಾಗದಿದ್ದಾಗ, ಅದು ಉತ್ಪಾದಕನಿಗೆ ನಿಧಾನಗೊಳಿಸಲು ಸಂಕೇತಿಸಬಹುದು. ಇದನ್ನು ಸ್ಟ್ರೀಮ್‌ನ ನಿಯಂತ್ರಕ ಮತ್ತು ರೀಡರ್/ರೈಟರ್ ಆಬ್ಜೆಕ್ಟ್‌ಗಳ ಮೂಲಕ ಸಾಧಿಸಲಾಗುತ್ತದೆ.
ReadableStream ನ ಆಂತರಿಕ ಕ್ಯೂ ಪೂರ್ಣಗೊಂಡಾಗ, ಕ್ಯೂನಲ್ಲಿ ಸ್ಥಳ ಲಭ್ಯವಾಗುವವರೆಗೆ pull() ವಿಧಾನವನ್ನು ಕರೆಯಲಾಗುವುದಿಲ್ಲ. ಅದೇ ರೀತಿ, WritableStream ನ 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. ನೈಜ-ಸಮಯದ ಡೇಟಾ ಫೀಡ್‌ಗಳು
ಸ್ಟಾಕ್ ಬೆಲೆಗಳು ಅಥವಾ ಸೆನ್ಸರ್ ರೀಡಿಂಗ್‌ಗಳಂತಹ ನೈಜ-ಸಮಯದ ಡೇಟಾ ಫೀಡ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ವೆಬ್ ಸ್ಟ್ರೀಮ್‌ಗಳು ಸಹ ಸೂಕ್ತವಾಗಿವೆ. ನೀವು ReadableStream ಅನ್ನು ಡೇಟಾ ಮೂಲಕ್ಕೆ ಸಂಪರ್ಕಿಸಬಹುದು ಮತ್ತು ಒಳಬರುವ ಡೇಟಾವನ್ನು ಅದು ಬಂದಂತೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಬಹುದು.
// ಉದಾಹರಣೆ: ನೈಜ-ಸಮಯದ ಡೇಟಾ ಫೀಡ್ ಅನ್ನು ಅನುಕರಿಸುವುದು
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 ಬಳಸುವ ಪ್ರಯೋಜನಗಳು
- ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆ: ಡೇಟಾವನ್ನು ಹಂತ ಹಂತವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಿ, ಮೆಮೊರಿ ಬಳಕೆಯನ್ನು ಕಡಿಮೆ ಮಾಡಿ ಮತ್ತು ಸ್ಪಂದನಶೀಲತೆಯನ್ನು ಸುಧಾರಿಸಿ.
- ವರ್ಧಿತ ಮೆಮೊರಿ ನಿರ್ವಹಣೆ: ಸಂಪೂರ್ಣ ಡೇಟಾಸೆಟ್‌ಗಳನ್ನು ಮೆಮೊರಿಗೆ ಲೋಡ್ ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಿ, ವಿಶೇಷವಾಗಿ ದೊಡ್ಡ ಫೈಲ್‌ಗಳು ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಸ್ಟ್ರೀಮ್‌ಗಳಿಗೆ ಉಪಯುಕ್ತ.
- ಉತ್ತಮ ಬಳಕೆದಾರ ಅನುಭವ: ಡೇಟಾವನ್ನು ಬೇಗನೆ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ಮತ್ತು ಪ್ರದರ್ಶಿಸಲು ಪ್ರಾರಂಭಿಸಿ, ಹೆಚ್ಚು ಸಂವಾದಾತ್ಮಕ ಮತ್ತು ಸ್ಪಂದನಾಶೀಲ ಬಳಕೆದಾರ ಅನುಭವವನ್ನು ಒದಗಿಸಿ.
- ಸರಳೀಕೃತ ಡೇಟಾ ಸಂಸ್ಕರಣೆ: TransformStreams ಬಳಸಿ ಮಾಡ್ಯುಲರ್ ಮತ್ತು ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ಗಳನ್ನು ರಚಿಸಿ.
- ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಬೆಂಬಲ: ಬದಲಾಗುತ್ತಿರುವ ಡೇಟಾ ದರಗಳನ್ನು ನಿರ್ವಹಿಸಿ ಮತ್ತು ಗ್ರಾಹಕರು ಅತಿಯಾದ ಹೊರೆಯಿಂದ ಬಳಲುವುದನ್ನು ತಡೆಯಿರಿ.
ಪರಿಗಣನೆಗಳು ಮತ್ತು ಉತ್ತಮ ಅಭ್ಯಾಸಗಳು
- ದೋಷ ನಿರ್ವಹಣೆ: ಸ್ಟ್ರೀಮ್ ದೋಷಗಳನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ವಹಿಸಲು ಮತ್ತು ಅನಿರೀಕ್ಷಿತ ಅಪ್ಲಿಕೇಶನ್ ನಡವಳಿಕೆಯನ್ನು ತಡೆಯಲು ದೃಢವಾದ ದೋಷ ನಿರ್ವಹಣೆಯನ್ನು ಅಳವಡಿಸಿ.
- ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆ: ಮೆಮೊರಿ ಸೋರಿಕೆಯನ್ನು ತಪ್ಪಿಸಲು ಸ್ಟ್ರೀಮ್‌ಗಳು ಇನ್ನು ಮುಂದೆ ಅಗತ್ಯವಿಲ್ಲದಿದ್ದಾಗ ಸಂಪನ್ಮೂಲಗಳನ್ನು ಸರಿಯಾಗಿ ಬಿಡುಗಡೆ ಮಾಡಿ.
reader.releaseLock()ಬಳಸಿ ಮತ್ತು ಸ್ಟ್ರೀಮ್‌ಗಳು ಸೂಕ್ತವಾದಾಗ ಮುಚ್ಚಲ್ಪಟ್ಟಿವೆ ಅಥವಾ ರದ್ದುಗೊಂಡಿವೆ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ. - ಎನ್‌ಕೋಡಿಂಗ್ ಮತ್ತು ಡಿಕೋಡಿಂಗ್: ಸರಿಯಾದ ಅಕ್ಷರ ಎನ್‌ಕೋಡಿಂಗ್ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಪಠ್ಯ-ಆಧಾರಿತ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು
TextEncoderStreamಮತ್ತುTextDecoderStreamಬಳಸಿ. - ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆ: ವೆಬ್ ಸ್ಟ್ರೀಮ್ಸ್ API ಬಳಸುವ ಮೊದಲು ಬ್ರೌಸರ್ ಹೊಂದಾಣಿಕೆಯನ್ನು ಪರಿಶೀಲಿಸಿ, ಮತ್ತು ಹಳೆಯ ಬ್ರೌಸರ್‌ಗಳಿಗಾಗಿ ಪಾಲಿಫಿಲ್‌ಗಳನ್ನು ಬಳಸುವುದನ್ನು ಪರಿಗಣಿಸಿ.
- ಪರೀಕ್ಷೆ: ನಿಮ್ಮ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ಗಳು ವಿವಿಧ ಪರಿಸ್ಥಿತಿಗಳಲ್ಲಿ ಸರಿಯಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತವೆಯೇ ಎಂದು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ಸಂಪೂರ್ಣವಾಗಿ ಪರೀಕ್ಷಿಸಿ.
ತೀರ್ಮಾನ
ವೆಬ್ ಸ್ಟ್ರೀಮ್ಸ್ API ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ ಸ್ಟ್ರೀಮಿಂಗ್ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸಲು ಒಂದು ಶಕ್ತಿಯುತ ಮತ್ತು ದಕ್ಷ ಮಾರ್ಗವನ್ನು ಒದಗಿಸುತ್ತದೆ. ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಮೂಲಕ ಮತ್ತು ವಿವಿಧ ಸ್ಟ್ರೀಮ್ ಪ್ರಕಾರಗಳನ್ನು ಬಳಸಿಕೊಳ್ಳುವ ಮೂಲಕ, ನೀವು ದೊಡ್ಡ ಫೈಲ್‌ಗಳು, ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳು, ಮತ್ತು ನೈಜ-ಸಮಯದ ಡೇಟಾ ಫೀಡ್‌ಗಳನ್ನು ಸುಲಭವಾಗಿ ನಿರ್ವಹಿಸಬಲ್ಲ ದೃಢ ಮತ್ತು ಸ್ಪಂದನಾಶೀಲ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ರಚಿಸಬಹುದು. ಬ್ಯಾಕ್‌ಪ್ರೆಶರ್ ಅನ್ನು ಅಳವಡಿಸುವುದು ಮತ್ತು ದೋಷ ನಿರ್ವಹಣೆ ಹಾಗೂ ಸಂಪನ್ಮೂಲ ನಿರ್ವಹಣೆಗಾಗಿ ಉತ್ತಮ ಅಭ್ಯಾಸಗಳನ್ನು ಅನುಸರಿಸುವುದು ನಿಮ್ಮ ಡೇಟಾ ಸಂಸ್ಕರಣಾ ಪೈಪ್‌ಲೈನ್‌ಗಳು ವಿಶ್ವಾಸಾರ್ಹ ಮತ್ತು ಕಾರ್ಯಕ್ಷಮತೆಯಿಂದ ಕೂಡಿರುವುದನ್ನು ಖಚಿತಪಡಿಸುತ್ತದೆ. ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ವಿಕಸನಗೊಳ್ಳುತ್ತಾ ಮತ್ತು ಹೆಚ್ಚು ಸಂಕೀರ್ಣ ಡೇಟಾವನ್ನು ನಿರ್ವಹಿಸುತ್ತಾ ಸಾಗಿದಂತೆ, ವೆಬ್ ಸ್ಟ್ರೀಮ್ಸ್ API ವಿಶ್ವಾದ್ಯಂತ ಡೆವಲಪರ್‌ಗಳಿಗೆ ಅತ್ಯಗತ್ಯ ಸಾಧನವಾಗಲಿದೆ.