Original subtitles

Streams are yet another fundamental concept

in Node.JS.

So let's now learn all about them.

So first of all, what are streams?

Well, with streams we can process meaning read and write

data piece by piece without completing the whole read

or write operation.

Therefore we don't have to keep all the data in memory

to do these operations.

For example, when we read a file using streams,

we read part of the data, do something with it,

then free our memory, and repeat this until the entire file

has been processed.

Or think of YouTube or Netflix,

which are both called streaming companies

because they stream video using the same principle.

So instead of waiting until the entire video file loads,

the processing is done piece by piece or in chunks

so that you can start watching even before the entire file

has been downloaded.

So the principal here is not just about Node.JS.

But universal to computer science in general.

So as you can see, this makes streams the perfect candidate

for handing large volumes of data like for example,

video or also data that we're receiving piece by piece

from an external source.

Also, streaming make the data processing more efficient

in terms of memory because there is no need

to keep all the data in memory and also in terms of time

because we can start processing the data as it arrives,

rather than waiting until everything arrives.

Okay, so now that we know what streams are,

let's talk a little bit about how they are implemented

in Node.JS.

So in Node, there are four fundamental types of streams:

readable streams, writable streams, duplex streams,

and transform streams.

But the readable and writeable ones

are the most important ones.

And so we're gonna focus more on these two.

So readable streams are the ones from which we can read.

We can consume data, makes sense right?

Now streams are everywhere in the core Node modules.

So a bit like events, like we talked about before.

For example, the data that comes in when an http server

gets a request is actually a readable stream.

So all the data that is sent with the request comes in

piece by piece and not in one large piece.

Also another example from the file system

is that we can read a file piece by piece

by using a read screen from the FS module,

which can actually be quite useful for large text files.

All right, now another important thing to note

is that streams are actually instances

of the EventEmitter class.

Meaning that all streams can emit and listen

to named events.

Just like we learned in the last lecture.

In the case of readable streams, they can emit,

and we can listen to many different events.

But the most important two are the data and the end events.

The data event is emitted when there is a new piece

of data to consume,

and the end event is emitted as soon as

there is no more data to consume.

And of course, we can then react

to these events accordingly.

And actually we're gonna do exactly that in the next video.

So to practice how to work with streams.

Finally, besides events, we also have important functions

that we can use on streams.

And in the case of readable streams,

the most important ones are the pipe and the read functions.

And again, you will see these in action in the next video,

especially the super important pipe function,

which basically allows us to plug streams together,

passing data from one stream to another

without having to worry much about events at all.

Okay, next up, writeable streams are the ones

to which we can write data.

So basically, the opposite of readable streams.

A great example is the http response that we can send back

to the client and which is actually a writeable stream.

So a stream that we can write data into.

So when we want to send data, we have to write it somewhere,

right?

And that somewhere is a writeable stream,

and that makes perfect sense, right?

For example, if we wanted to send a big video file

to a client, we would stream that result

just like Netflix or YouTube do.

Now about events, the most important ones are

the drain and the finish events.

And the most important functions are

the write and end functions,

some of which you will see in action in the next lecture.

Now quickly about duplex streams.

They're simply streams that are both readable and writeable

at the same time.

These are a bit less common.

But anyway, a good example would be a web socket

from the net module.

And a web socket is basically just a communication channel

between client and server that works in both directions

and stays open once the connection has been established.

Finally, transform streams are duplex streams,

so streams that are both readable and writeable,

which at the same time can modify or transform

the data as it is read or written.

A good example of this one is the zlib core module

to compress data which actually uses a transform stream.

All right, and that's the four types of streams

and a broad overview of how we can use them.

Now there is something important to mention here

before we move on,

which is a fact that these events and functions

that I showed you are for consuming streams

that are already implemented like the ones

that I showed you here as our examples.

So for example, Node implemented these http requests

and responses as streams,

and we can then consume, we can use them

using the events and functions that are available

for each type of stream.

We could of course also implement our own streams

and then consume them using these same events and functions.

That however would be a video for another time

because in order to build most apps,

it's most important to know how to actually consume streams,

not really how to implement them.

All right, so let's now move on

and actually use streams in practice.