Depending on the methods implemented, a stream becomes Readable, Writable, or Duplex (both readable and writable). Full featured Promises/A+ implementation with exceptionally good performance, A light-weight module that brings window.fetch to node.js, Handlebars provides the power necessary to let you build semantic templates effectively with no frustration, Parse, validate, manipulate, and display dates.

is defined in the stream.Readable class.

For example, the following will result in an error. Assuming res is an HTTP response object, you often do the following to send the response to browser: When end() is called and every chunk of data has been flushed, a finish event is emitted by the stream. When you dont have more data to write you can simply call end() to notify the stream that you have finished writing.

At this moment, the stream has ended. But the easiest and cleanest way is to use piping and chaining. Have a look at the following snippet: First, we create a simple readable stream from the file input.txt.gz. By default, readable.read() returns the data in a Buffer object. We use a while loop to consume data in chunks of 8 bytes from the internal buffer, using the readable.read() method. As a result, its very good at handling I/O bound tasks.

Next, we use the readable.on('readable') handler, which allows fine-grained control over the transfer of data. Piping is a great mechanism in which you can read data from the source and write to destination without managing the flow yourself. However, if the stream has ended, then all of the remaining data in the internal buffer is returned. The writable stream will let you know when you can start writing more data by emitting a drain event. When the readable stream is in flowing mode, readable.read() is automatically called until the data elements from the stream are fully consumed. The program prints each chunk and stores them in the array chunks. You just need to call read() on the stream instance repeatedly until every chunk of data has been read. size: Optional parameter that specifies how much data is to be read in bytes. Support loaders to preprocess files, i.e. Next, we pipe this stream into another stream zlib.createGunzip() to un-gzip the content. If true, then the write was successful and you can keep writing more data. Stream Module in Node.js provides the API for handling the sequence of data flowing over time. If you are reading strings this may not be suitable for you. A readable stream lets you read data from a source. As a result, the data is interpreted as utf8 and passed to your callback as string. When you are reading data from a file you may decide you emit data event once a line is read. Here are some more stream methods you need to know: Writable streams let you write data to a destination. We will use these events to work with the streams. This function returns a Boolean value indicating if the operation was successful. json, jsx, es7, css, less, and your custom stuff. Packs CommonJs/AMD modules for the browser. You might have used fs module which lets you work with both readable and writable file streams. It can be a simple file on your file system, a buffer in memory or even another stream. 10 Node.js Best Practices: Enlightenment from the Node Gurus, Build a Node.js-powered Chatroom Web App: Node, MongoDB and Socket. Sandeep is the Co-Founder of Hashnode. As soon as you listen to data event and attach a callback it starts flowing. Learn in-demand tech skills in half the time. So, lets explore Streams in detail and understand how they can simplify I/O. Assume that you have an archive and want to decompress it. Finally, since there is no more data available, the readable.on('end') handler is fired, which concatenates all chunks from the array chunks and displays the whole file content.

To write data to a writable stream you need to call write() on the stream instance. The readable.read() method in the Node.js Stream Module is used to read data from the internal Buffer when the readable stream is in paused mode. The stream implementor decides how often data event is emitted. Lastly, as streams can be chained, we add a writable stream in order to write the un-gzipped content to the file.

Did you like the article? Note that the readable event is emitted when a chunk of data can be read from the stream. Node.js is asynchronous and event driven in nature. For example, in a Node.js based HTTP server, request is a readable stream and response is a writable stream. The source can be anything.

Since our internal buffer contains our readable stream data, the program proceeds inside readable.on('readable') and prints Stream is now readable.

When there is nothing to read, it returns null.

So, in the while loop we check for null and terminate the loop. If size is not specified, then all of the data from the internal buffer is returned. In this article, we will discuss readable and writable streams. You should also note that pipe() returns the destination stream.

It simply reads chunks of data from an input stream and writes to the destination using write(). If you are working on an app that performs I/O operations, you can take advantage of the streams available in Node.js. As streams are EventEmitters, they emit several events at various points.

The stream types supported in the Node.js Stream Module are: All of these streams are implemented as classes in the Stream Module. readable.read() returns Null when 8 bytes are not available to read, and the while loop terminates. This makes pipe() a neat tool to read and write data. The following snippet demonstrates this technique. If false is returned, it means something went wrong and you cant write anything at the moment. The readable.resume() method The best way to read data from a stream is to listen to data event and attach a callback. By default, Buffer object is returned unless the stream is in object mode or an encoding is specified using the readable.setEncoding() method. Streams, pipes, and chaining are the core and most powerful features in Node.js.

If there is no data left in the internal buffer, then Null is returned. We discussed some of the important concepts in readable streams. So, you can set encoding on the stream by calling Readable.setEncoding(), as shown below.

Lets see how! Allows to split your codebase into multiple bundles, which can be loaded on demand. The above code is straightforward. If used responsibly, streams can indeed help you write neat and performant code to perform I/O. There is also another way to read from stream. Just note that you cant write to the stream after calling end(). Must be of data type and less than or equal to 1 GiB. Like readable streams, these are also EventEmitters and emit various events at various points. However, since the string () remains in the internal buffer, the readable.on('readable') handler is fired again and the readable.read() reads the remaining string in the internal buffer. Simply put, a stream is nothing but an EventEmitter and implements some specials methods. Duplex streams are beyond the scope of this article. Readable streams let you read data from a source while writable streams let you write data to a destination. Initially, the stream is in a static state. When there is no more data to read (end is reached), the stream emits an end event. Lets see various methods and events available in writable streams. In the above snippet, we listen to this event to get notified when the end is reached. By default the data you read from a stream is a Buffer object. As pipe() manages the data flow for you, you should not worry about slow or fast data flow. For example, Readable streams follow the interface defined by stream.Readable class. Readable streams run in two modes: flowing or paused. When a chunk of data is available, the readable stream emits a data event and your callback executes. Here are some important events related to writable streams: This was all about the basics of streams.

Copyright 2022 Educative, Inc. All rights reserved. There are a number of ways to achieve this. He loves startups and web technologies. Take a look at the following snippet: The above snippet makes use of the pipe() function to write the content of file1 to file2. This site is protected by reCAPTCHA and the Google Privacy Policy and Terms of Service apply. Do let us know what you think via comments. For example, an HTTP request may emit a data event once a few KB of data are read. Copyright 2022 Educative, Inc. All rights reserved.

Now that you know the basics, lets understand different type of streams. So, you can easily utilize this to chain multiple streams together. The following are a few examples of Readable streams: In the above code, we first create a readable stream that uses data from example.txt, which contains the string How to use readable.read(). In the above snippet we set the encoding to utf8. Other return values are the following: If complete size bytes are not present in the internal Buffer, then Null is returned. After that, chunks of data are read and passed to your callback. The read() function reads some data from the internal buffer and returns it. If you have already worked with Node.js, you may have come across streams. Streams are unix pipes that let you easily read data from a source and pipe it to a destination. Take a look at the following snippet: The function call fs.createReadStream() gives you a readable stream.