1 / 10

Streams in Node

https://techvidvan.com/tutorials/streams-in-nodejs/

Sudhanshi
Download Presentation

Streams in Node

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. Streams in Node.js In this article, we will discuss Streams In Node.js .One of the key features of Node.js is its ability to handle streams, which are used to efficiently process large amounts of data in real-time. In simple terms, a stream is a sequence of data that is continuously flowing from one point to another. In Node.js, streams are objects that facilitate the efficient processing of large amounts of data in a non-blocking and event-driven way. What are Streams? Streams are a way of handling input and output data in Node.js. They allow data to be read or written in small chunks, rather than loading the entire file or data set into memory. This can be particularly useful for large data sets or network connections, where loading everything into memory at once could cause performance issues. Streams are based on the concept of a sequence of data elements that are processed one at a time. A stream is essentially a sequence of chunks of data, which can be read or written in a sequential manner. Streams can be used to read or write data from files, network sockets, or even memory buffers. Streams in Node.js can be classified into four types: Readable, Writable, Duplex, and Transform streams. Readable streams in Node.js

  2. As the name suggests, a Readable stream is used to read data from a source. For example, you can use a Readable stream to read data from a file, a network socket, or a database. A Readable stream emits events such as ‘data’, ‘end’, and ‘error’, which you can listen to in order to handle the data being read. Writable streams in Node.js A Writable stream is used to write data to a destination. Writable stream is a mechanism that allows data to be written to a destination. For example, you can use a Writable stream to write data to a file, a network socket, or a database. A Writable stream also emits events such as ‘drain’, ‘finish’, and ‘error’, which you can listen to in order to handle the data being written. Duplex streams in Node.js A Duplex stream is a combination of a Readable and a Writable stream. It allows you to read data from a source and write data to a destination at the same time. Duplex streams can be useful for applications that require bidirectional communication, such as chat applications or real-time games. Transform streams in Node.js A Transform stream is a type of Duplex stream that can be used to modify data as it flows through the stream. For example, you can use a Transform stream to compress data, encrypt data, or convert data from one format to another.

  3. Why are streams important? Streams are important for building efficient and scalable applications because they allow you to process large amounts of data in small chunks, without loading the entire dataset into memory. This is particularly useful for applications that deal with large files or real-time data streams. In addition, streams are non-blocking and event-driven, which means that they can run concurrently with other parts of your application. This allows you to build applications that can handle multiple requests at the same time, without being slowed down by I/O operations. How to use streams in Node.js Using streams in Node.js is straightforward. To create a stream, you first need to import the ‘stream’ module: const stream = require('stream'); Once you have the stream module imported, you can create a stream by instantiating one of the four types of ‘streams’: const readableStream = new stream.Readable(); const writableStream = new stream.Writable(); const duplexStream = new stream.Duplex(); const transformStream = new stream.Transform();

  4. After creating a stream, you can use methods such as ‘read’, ‘write’, ‘pipe’, and ‘end’ to interact with the data. For example, you can use the ‘write’ method to write data to a writable stream: writableStream.write('Hello, World!'); You can also use the ‘pipe’ method to transfer data from a readable stream to a writable stream: readableStream.pipe(writableStream); Examples Here are some examples of how you can use streams in Node.js: Reading a File in Nodejs To read a file using a readable stream, you can use the fs module to create a readable stream: const fs = require('fs'); const readableStream = fs.createReadStream('input.txt'); readableStream.on('data', function(chunk) { console.log(chunk); });

  5. Output This code reads a file named ‘input.txt’ and creates a readable stream from it. The on method is used to listen for the ‘data’ event, which is emitted each time a chunk of data is read from the stream. Writing to a File in Nodejs To write data to a file using a writable stream, you can use the fs module to create a writable stream: const fs = require('fs'); const writableStream = fs.createWriteStream('output.txt'); writableStream.write('Hello, World!'); Output Hello World! This code creates a writable stream to a file named ‘output.txt’ and writes the string ‘’Hello, World!’’ to it. Transforming Data in Nodejs To transform data using a transform stream, you can create a custom transform stream that modifies the data as it is being read or written. Here is an example:

  6. const stream = require('stream'); class UpperCaseTransform extends stream.Transform Piping or chaining streams in Nodejs Piping or chaining streams is a way to connect multiple streams together so that the output of one stream becomes the input of the next stream, creating a data processing pipeline. This can be very useful when working with large amounts of data or when performing complex data transformations. In Node.js, streams are a powerful and flexible way to handle data processing, allowing you to read and write data in chunks, rather than loading it all into memory at once. Streams can be piped together using the ‘pipe()’ method. Here is an example of how to read data from a file, convert it to uppercase, and write it to another file using piping: const fs = require('fs'); // create a read stream from input.txt const readStream = fs.createReadStream('input.txt'); // create a write stream to output.txt const writeStream = fs.createWriteStream('output.txt'); // pipe the read stream to the write stream, converting to uppercase readStream.pipe( new Transform({ transform(chunk, encoding, callback) { callback(null, chunk.toString().toUpperCase()); }

  7. }) ).pipe(writeStream); In this example, we create a read stream from the file ‘input.txt’ and a write stream to the file ‘output.txt’. We then pipe the read stream to a ‘Transform’ stream that converts the data to uppercase and pipes it to the write stream. Another example using piping can be seen in the following code snippet where we use ‘http’ module to create a server that reads a request from a client, converts the request data to uppercase and sends the result back to the client: const http = require('http'); http.createServer((req, res) => { // create a writable stream to store the transformed data const writeStream = new Writable({ write(chunk, encoding, callback) { res.write(chunk.toString()); callback(); } }); // pipe the request stream to the write stream, converting to uppercase req.pipe( new Transform({ transform(chunk, encoding, callback) { callback(null, chunk.toString().toUpperCase()); } }) ).pipe(writeStream); }).listen(3000);

  8. Writable streams in Node.js In Node.js, streams are a core part of the API and they provide a powerful mechanism for handling data in a flexible and efficient way. One of the key types of streams is the Writable stream. A Writable stream is a mechanism for writing data to a destination. Writable streams are used to write data to a variety of destinations, including files, sockets, and HTTP responses. Here’s an example of how to create a writable stream in Node.js: const { Writable } = require('stream'); const writableStream = new Writable({ write(chunk, encoding, callback) { // do something with the chunk of data console.log(`Received chunk: ${chunk.toString()}`); // call the callback to signal that the chunk has been processed callback(); } }); In this example, we create a new ‘Writable’ stream using the Writable class from the Node.js ‘stream’ module. The ‘write’ method is called every time data is written to the stream. The ‘chunk’ parameter contains the data that was written, the ‘encoding’ parameter specifies the encoding of the data, and the ‘callback’ parameter is a function that must be called when the data has been processed.

  9. To use the Writable stream, we can write data to it using the ‘write()’ method: writableStream.write('Hello, world!'); This will write the string “Hello, world!” to the writable stream. It’s important to note that the ‘write()’ method is asynchronous, so it returns ‘true’ if the data was successfully written to the stream’s internal buffer, or ‘false’ if the buffer is full and the data cannot be written yet. You can also use the ‘end()’ method to signal the end of the stream: writableStream.end(); This will close the stream and signal that no more data will be written to it. Overall, Writable streams provide a flexible and efficient way to write data to various destinations, and are a fundamental part of the Node.js streaming API. Advantages of Streams Streams have several advantages over traditional data processing methods, especially when it comes to handling large amounts of data. Here are some of the main advantages of using streams: ● Memory efficiency: Streams can handle large amounts of data without requiring a large amount of memory. ● Processing speed: Streams can start processing data immediately, leading to faster processing times.

  10. ● Modular design: Streams are modular and can be easily combined and reused to create more complex data processing pipelines. ● Backpressure: Streams provide built-in backpressure mechanisms that prevent data loss or resource exhaustion. ● Compatibility: Streams are a core part of the Node.js API and are widely supported in many other programming languages and frameworks. Conclusion: Streams are a powerful abstraction in Node.js that allow data to be read or written in chunks. They can be used to handle input and output data in a sequential manner, which is particularly useful for large data sets or network connections. ● Streams can handle input and output data. ● They work in a sequential manner. ● This is useful for large data sets. ● This is also useful for network connections. Node.js provides four stream types, namely Readable, Writable, Duplex, and Transform, which serve distinct purposes in processing data. By using the methods provided by the stream module, developers can easily create and use streams to handle data in a more efficient and scalable way.

More Related