?? Node.js Streams: Lighting Up Your Data Highway!
Node.JS Streams

?? Node.js Streams: Lighting Up Your Data Highway!

Aakash Khatkar Aakash Khatkar

Aakash Khatkar

Lead Backend Engineer | Gen AI | Distributed Systems | Node.js | AWS

发布日期: 2024年7月6日
+ 关注

Imagine you’re gazing at a stunning long exposure photo of cars zooming down a highway at night. The headlights and taillights create beautiful, continuous streams of light. This is exactly how Node.js streams work – efficiently moving data along without causing a traffic jam in your system. Let’s dive into the world of Node.js streams and learn how to illuminate your data highways like a pro!

Types of Streams ???

In the Node.js universe, there are four types of streams you need to master to keep your data moving smoothly:

1. Readable Streams: The inbound lanes bringing data to you. ??

2. Writable Streams: The outbound lanes sending data away. ??

3. Duplex Streams: The bidirectional lanes handling traffic both ways. ??

4. Transform Streams: The construction zones where data gets transformed on the fly. ??

Let’s explore each type with examples and comments to guide you through the flow.

Readable Streams ??

Readable streams are like cars entering the highway, bringing data to your application one chunk at a time. Here’s how you can create and use a readable stream:

const fs = require('fs'); // Create a readable stream from a file const readableStream = fs.createReadStream('example.txt'); // 'data' event is fired when a chunk of data is available to read readableStream.on('data', (chunk) => { console.log(`Received ${chunk.length} bytes of data.`); console.log(chunk.toString()); }); // 'end' event is fired when there is no more data to read readableStream.on('end', () => { console.log('No more data. ??'); }); // 'error' event is fired if something goes wrong readableStream.on('error', (err) => { console.error('An error occurred: ??', err); });
Node.js Read Stream


Writable Streams ??

Writable streams are like cars exiting the highway, sending data out from your application:

const fs = require('fs'); // Create a writable stream to a file const writableStream = fs.createWriteStream('output.txt'); // Write data to the stream writableStream.write('Hello, World! ??\n'); writableStream.write('Writing data to a file using streams. ??\n'); // End the stream (no more data will be written) writableStream.end(); // 'finish' event is fired when all data has been flushed to the file writableStream.on('finish', () => { console.log('All data has been written. ?'); }); // 'error' event is fired if something goes wrong writableStream.on('error', (err) => { console.error('An error occurred: ??', err); });
Node.js Write Stream

领英推荐

Duplex Streams ??

Duplex streams are like special lanes that allow data to flow both in and out, keeping the traffic moving in both directions:

const net = require('net'); // Create a TCP server const server = net.createServer((socket) => { console.log('Client connected. ??'); // 'data' event is fired when data is received from the client socket.on('data', (data) => { console.log(`Received data: ${data}`); // Echo the data back to the client socket.write(`You said: ${data}`); }); // 'end' event is fired when the client disconnects socket.on('end', () => { console.log('Client disconnected. ???♂?'); }); }); // Start the server and listen on port 8080 server.listen(8080, () => { console.log('Server listening on port 8080. ??'); });
Node.js Duplex Stream (Socket)

Transform Streams ???

Transform streams are like construction zones where the data gets transformed into something new before continuing its journey:

const { Transform } = require('stream'); // Create a transform stream that uppercases the data const uppercaseTransform = new Transform({ transform(chunk, encoding, callback) { // Convert the chunk to a string, uppercase it, and push it this.push(chunk.toString().toUpperCase()); callback(); } }); // Pipe the input to the transform stream, then to the output process.stdin.pipe(uppercaseTransform).pipe(process.stdout);

Piping Streams ??

Piping streams together is like connecting different sections of a highway, ensuring the smooth flow of data from start to finish:

const fs = require('fs'); const zlib = require('zlib'); // Create a readable stream from a file const readableStream = fs.createReadStream('example.txt'); // Create a writable stream to a compressed file const writableStream = fs.createWriteStream('example.txt.gz'); // Create a transform stream to compress data const gzip = zlib.createGzip(); // Pipe the readable stream through the gzip stream, then to the writable stream readableStream.pipe(gzip).pipe(writableStream); writableStream.on('finish', () => { console.log('File has been compressed. ???'); });
Node.js Piping streams

Error Handling in Streams ??

Even on the smoothest highways, you might encounter a roadblock. Here’s how to handle errors in streams gracefully:

const fs = require('fs'); // Attempt to create a readable stream from a non-existent file const readableStream = fs.createReadStream('nonexistent.txt'); // 'error' event is fired if something goes wrong readableStream.on('error', (err) => { console.error('An error occurred: ??', err.message); });
Error Handling in Node.js

Conclusion ??

Streams are the backbone of Node.js, ensuring data flows smoothly through your applications just like cars on a well-maintained highway. By mastering readable, writable, duplex, and transform streams, you can keep your data highways clear and efficient. So gear up, hit the road, and let your data streams shine like headlights on a dark night! ????

Happy coding, and may your streams never jam! ????



要查看或添加评论，请登录

Aakash Khatkar的更多文章

社区洞察

其他会员也浏览了