This is one of the few channels that you realize from the onset that the instructor understands what he is talking about and knows how to share the knowledge. Thank you sir!
Thanks for sharing your knowledge! I'm pretty new to node.js, and I had trouble reading data received from an API call because it was in chunks (). Thanks for explaining that it all comes down to specifying the 'character encoding' and making everything seem so easy and simple.
For those of you who wonder why the buffer is not presenting as the file text after adding utf8 as 3rd parameter: pass an object as 3rd parameter {encoding: 'utf8'} like this: var myReadStream = fs.createReadStream(__dirname + '/readme.txt', {encoding: 'utf8'});
Just a note. Actually, you don't need to do that. I will explain you why: First, the dirname + readMe thing is only one parameter, which makes utf8 the second one. Note: You also want to write readMe with capital M, unless you named the file differently. Taking that into account, the docs of Node say about the options object: "If options is a string, then it specifies the encoding." Now I just learned about this and it's cool. Means if you just say 'utf8' (notice quotation, because it's a string), then you don't need the options object at all. Cool! :)
Great tutorial. I'm going through them all sequentially. For this tutorial, a brief explanation as to what these number values in the buffer represent would be nice. I assume that they correspond with the text in some way, but the tutorial did not go into this in order to confirm.
Just a small correction, __dirname is not a global property. Every node js file is actually wrapped in function when it's executed. And one of the parameters is __dirname. Below you could see the wrapper function: function (exports, require, module, __filename, __dirname) { // file contents here. } That's the reason __dirname and __filename is unique to each file, if it's listed under the global object, it won't be unique.
the default is 64KB (65,536 bytes), you can set it to whatever you want by passing a config options object and setting the highWaterMark property like this to 900KB for example: const readableStream = fs.createReadStream(__dirname + "/loremIpsum.txt", { highWaterMark: 900000 }); You can check the buffer's size with: console.log(readableStream.readableHighWaterMark); // outputs 65536 bytes, the default buffer size, assuming you didn't change highWaterMark.
Great tutorial, I used arrow function and it translated the content of my lorem ipsum. I didn't include utf-8 readableStream.on('data', (chunk) => console.log("New Chunk Recieved " + chunk))
Excellent tutorial, thanks. Just one small correction (as of Oct 2017), in fs.createReadStream() instead of 'utf8' parameter, it should be {encoding: 'utf8'} Thanks
Just a note. Actually, you don't need to do that. I will explain you why: The docs of Node say about the options object: "If options is a string, then it specifies the encoding." (nodejs.org/api/fs.html#fs_fs_createreadstream_path_options) Now I just learned about this and it's cool. Means if you just say 'utf8' (notice quotation, because it's a string), then you don't need the options object at all. Cool! :)
what makes the reading emitted? is it the createReadStream? in this case aren't we losing the first chunks that come before we used "on" to listen ? i feel like we need to listen first and then start the reading. what am i missing?
I was curious about this so I asked chatgpt and it explained it nicely. Basically the streaming won't start until the entire module/file is executed. So it's guaranteed that you won't lose any buffer/bytes at all. In Node.js when you call `fs.createReadStream()`, it sets up the stream, but the streaming of data (i.e., the reading of data from the file and emitting it as `data` events) does not start immediately at the moment of this call. Instead, the streaming process begins later, allowing you to set up your event listeners in the meantime. # Understanding the Flow 1. Creating the Stream: `fs.createReadStream()` creates a readable stream but doesn't immediately start reading data from the file. It just initializes the stream and gets it ready to read data. 2. Event Loop Integration: The actual reading of data is integrated with the Node.js event loop. The stream starts reading data when it gets an opportunity to execute within the event loop. This typically happens after the current executing script i.e. the current module/file (including all synchronous code and immediate function calls) completes. 3. Attaching Event Listeners: This delay before streaming starts allows you to attach event listeners like `readableStream.on('data', callback)`. If the stream started emitting data immediately upon creation, there would be a risk of missing early `data` events before the listeners are set up. 4. Starting the Stream: The stream effectively starts when Node.js's event loop processes it, which happens after the current tick of the event loop. This behavior ensures that you can attach `data`, `error`, `end`, and other event listeners in the same tick of the event loop as the stream creation, without missing any events. # Example const readableStream = fs.createReadStream(__dirname + "/readme.txt"); // Even though the stream is created, it hasn't started emitting 'data' events yet. readableStream.on('data', function (block) { console.log("new blocks received:"); console.log(block); }); // The 'data' events will start after this point, when the Node.js event loop begins processing the stream. In this example, the `data` event listener is attached immediately after creating the stream, ensuring that you won't miss any of the `data` events once the stream starts emitting them.
@@pozeraczstivow6348 I pretty much gave up on node.js for right now. I'm coming from JavaScript/PHP/MySQL background and I think I prefer PHP after learning Node.
Can anyone please tell me why he didnt use my ReadStream.emit(data , chunk); ??? becuase in 8th tutorial he kinda use all three the event emitter,the binder (.on) and the .emit.
can we send a request from another file? ive tried to do this and it tells me the "require" function is undefined, do i have to tell my files to use node-js somehow?? thank you for the videos!!
Do you or can you do one similar to this but with csv with large file size? Something like 32,000KB? I'm having issues with these chunks and it appears the stream just stops.
This is an old video but I'm hoping someone may be able to answer this: When exactly does an event listener stop listening? For example what if the data event we're listening for in the tutorial never fires? When I arbitrarily cause it to never fire in my code, the program exits out very quickly, which confuses me because if the whole point of event listeners is to listen out for events, shouldn't it just listen indefinitely, similar to how running listen() on an http.Server object causes your program to remain open indefinitely?
can you explain reading json file, where i manipulate some data then it will write that manipulated data. Because it is storing chucks of data i could not modify my json data. i have 54940 records while readStream it is storing 643 records in first chunk, where the last record is not complete json(example-->{ "_id" : "PERFSTG26226", "bonuses" : [ ) where my json data is incomplete. how can i read exactly if it is storing size wise not according to number of records.
i am new to node.js and want to ask, why need to require http as first line of code 'cos in this example, i am not seeing it being use. is there depecencies over at the fs ?
He explained it near the end of the video. It's so the user can start reading the data before it's fully read. Useful when they want to read a really big file (like a video) or they're on a really slow connection.
I want to get data about songs currently playing from a radio station. Like getting data from a streaming URL that looks like s2.randomname.com:7392. How do I do this?
why does Node.js force us to stream data rather than buffer it ? what are the difference b/w these two ? why performance is good in streams as compared to buffer ?
A stream is just packets of data being sent across the connection. So if you are sending some text from the server to the client like: The quick brown fox jumps over the lazy dog And your buffer is 1 byte, then you will just send one character at a time. If it is 5 bytes, you will send: "The q" "uick " "brown" " fox " "jumps" " over" " the " "lazy " "dog" Try to think of each chunk as a box of data, and think of all the data boxes received so far as the buffer. The stream is just the process of transferring of the boxes sequentially from the client to the server. So as soon as the client program receives the first chunk, it can display The q, then The quick , then The quick brown, etc, etc. The buffers ARE the stream. But normally a program, like a web browser, will wait until all the data is received to display the web page (imagine what the page would look like if only half the code is there). But if you are sending audio or video, the browser will start displaying whatever it has received so far once there is enough data in the buffer. The process is essentially the same whether you are sending text data or video data, because all the data is sent as bytes. It is up to the client to interpret them. When you stream a video online and it says "buffering", it means your browser is processing and playing the video/audio data quicker than it is being downloaded, so you got to the last chunk and now you have to wait for a bunch of new packets to come in from the server (ie, it's loading new data into a buffer that you can start reading from again). You have 'consumed' all the data in all the boxes you have received, and it won't start streaming again until it receives a certain amount of data to give you a good new buffer. If you think about it, all data transfer from a server to a client is a stream, and all the data received so far on the client-side is the buffer. Even if you sent a stream of characters one at a time, as soon as you receive 1 character, you are filling your buffer, even if you consume it immediately. The buffer is just some temporary space in memory to store the data you've received. Then the data can be displayed to you, or saved to the disk, cached, etc.
HI. I have a question. How we can see how works buffer with chunks without FileSystem module, but only with stream module For example const { Readable } = require('stream'); class Ever extends Readable { constructor(opt) { super(opt) } _read(chunks) { .... } let myRead = new Ever({}); myRead.on('data', (chunks) => { console.log('Received: '); console.log(chunks); });
// guys ignore this const http = require('http'); const fs = require('fs'); // createReadStream inherits from events.EventEmitter let myReadStream = fs.createReadStream(__dirname + '/readMe.txt' , 'utf8'); // if utf8 is not mentioned bytes will be returned // Every time when a stream is ready it emits an event names data myReadStream.on('data', function(chunk){ // listening for 'data' console.log('new chunk: ' ); console.log(chunk); }
How would you know when to emit it? You wouldn't, because it's a builtin functionality. You can emit your own events like in the previous tutorials, but node can also emit events, which you can make your script listen for, just like you can listen for events in a browser in javascript (ie. onload, onclick, etc.). Think of this as ondata
I tried concatenating [ console.log(chunk, + 'New chunk recieved:'); ] and got the text then a NaN value. Then i tried [ console.log('New chunk recieved:', + chunk); ] and got New chunk recieved: NaN New chunk recieved: NaN. Why does this happen? I know NaN means Not A Number.
I only get one "new chunk received:" and under it is the whole text. Without the 'utf8', it says: My Lorem_Ipsum.txt is 53kB. Why does it read it all at once? How do I split it into more than one chunk?
For anyone else wondering about this, I've found the answer. Visual Studio Code says: "Unlike the 16 kb default highWaterMark for a stream.Readable, the stream returned by this method has a default highWaterMark of 64 kb." So I copy-pasted the whole file's contents so it's 106kB and now it makes 2 chunks :) One step closer to understanding it all.
This is one of the few channels that you realize from the onset that the instructor understands what he is talking about and knows how to share the knowledge. Thank you sir!
i am a mobile dev, the first time i come with NodeJS, i saw many tut on the internet, but this series video is the best fot beginer :D, many thanks ^^
Thanks for sharing your knowledge! I'm pretty new to node.js, and I had trouble reading data received from an API call because it was in chunks (). Thanks for explaining that it all comes down to specifying the 'character encoding' and making everything seem so easy and simple.
I have hard time to understand the Stream, after watch ur video, I just got it so easily. Thank you so much ! you are awesome!!!
It is a crime to dislike these videos 😂😂
You are an amazing teacher! Thank you ;)
Thanks :D
Seriously though
Fantastic tutorial... buffer and streams are simply and clearly explained
for me... the best nodejs tutorial i found!
High quality tutorials, you've earned yourself a subscriber
Thanks :)
this indeed is the best tutorials in the world
Excellent. You are one of the best teacher. Thank you!
Thanks!
i am gonna pass my web development semester through ur tutorials
For those of you who wonder why the buffer is not presenting as the file text after adding utf8 as 3rd parameter:
pass an object as 3rd parameter {encoding: 'utf8'} like this:
var myReadStream = fs.createReadStream(__dirname + '/readme.txt', {encoding: 'utf8'});
Just a note. Actually, you don't need to do that. I will explain you why:
First, the dirname + readMe thing is only one parameter, which makes utf8 the second one.
Note: You also want to write readMe with capital M, unless you named the file differently.
Taking that into account, the docs of Node say about the options object: "If options is a string, then it specifies the encoding." Now I just learned about this and it's cool. Means if you just say 'utf8' (notice quotation, because it's a string), then you don't need the options object at all. Cool! :)
Great tutorial. I'm going through them all sequentially. For this tutorial, a brief explanation as to what these number values in the buffer represent would be nice. I assume that they correspond with the text in some way, but the tutorial did not go into this in order to confirm.
Great tutorial. You are a great teacher!
bestest of the best node.js tutorial. Thanks a lot.
Thanks dude 😊
Just a small correction, __dirname is not a global property. Every node js file is actually wrapped in function when it's executed. And one of the parameters is __dirname.
Below you could see the wrapper function:
function (exports, require, module, __filename, __dirname) {
// file contents here.
}
That's the reason __dirname and __filename is unique to each file, if it's listed under the global object, it won't be unique.
that should be a IIFE function BTW
That's some valuable content. Thank you :)
just wow - more please ! xD
thanks, sir.. finally I understand node js
Awesome videos mate, thanks for making these!
Thank you a lot !!! You are a really good teacher !!! It help me a lot !
Thanks! so easy video. Make more node videos
Fantastic overview.
you can pipe the output of this file to and then search for the chunks:
node server.js | less
then you search with /new
also, while in `less` after searching for a specific string, you can press `n` for the next results, and press `shift+n` for the previous results.
very best tutorial
Thank you so much :) you teach really nice!
I would like to thank you for the effort you made it do this tutorial. by the way, can we use this function for reading an image buffer?
How buffer size / chunk size is decided ?? how does it decide that it will need 2 chunks ?
the default is 64KB (65,536 bytes), you can set it to whatever you want by passing a config options object and setting the highWaterMark property like this to 900KB for example:
const readableStream = fs.createReadStream(__dirname + "/loremIpsum.txt", { highWaterMark: 900000 });
You can check the buffer's size with:
console.log(readableStream.readableHighWaterMark); // outputs 65536 bytes, the default buffer size, assuming you didn't change highWaterMark.
Sir I am in love with your teaching skills as well as coding skills. Can I talk to you please if there is a way? Please Sir ;)
Hey you can message me on Instagram @thenetninja :) . I'll try my best to reply but cannot always do so.
great video, thank you
you can set encoding by using the built in function tooo..like :
myReadStream.setEncoding('utf-8');
Doing , 'utf8' as an argument takes up less characters and less time.
awesome...!!! i am subscribed to you wagan...
Why am I amused by the way you say 'chunks'.
scottish??
@@adityajain019 Basically, although I think he'd have something to say about that XD
Great video, thanks, I'd like to know what extension you use to have terminal into atom
Great keep it up!
Great tutorial, I used arrow function and it translated the content of my lorem ipsum. I didn't include utf-8
readableStream.on('data', (chunk) => console.log("New Chunk Recieved " + chunk))
You must have included them in the createReadStream function right?
why his tutorial doesnt work and we should think and change some things?
Feliks Bekeshov Net ninja posted updated NodeJS tutorials bro. Some of this lessons are outdated
In Portuguese we say: "Caralho, que aula foda. Puta que pariu!"
Translating: "Good teacher." =)
LMAO, I put into google translate!
very nice .. thank you :)
great, thank you!
Can I create a read stream from a file on the internet? Also... it was difficult to find documentation on this. Thank you for this video!
I'd assume you provide a link to the file instead of a path to your directory.
You're the best.
Is this tutorial series sufficient as a pre-requisite for other courses which make use of node js development like in chatbots?
THANK YOU
I am good at English， but I can see it ,thanks a lot
Thanks for the brilliant tutorial..
So .. Can I define my own chunk size to read? I can see that the chunk size is quite high..
wonderful
Thank you
Excellent tutorial, thanks. Just one small correction (as of Oct 2017), in fs.createReadStream() instead of 'utf8' parameter, it should be {encoding: 'utf8'}
Thanks
Just a note. Actually, you don't need to do that.
I will explain you why:
The docs of Node say about the options object: "If options is a string, then it specifies the encoding." (nodejs.org/api/fs.html#fs_fs_createreadstream_path_options) Now I just learned about this and it's cool. Means if you just say 'utf8' (notice quotation, because it's a string), then you don't need the options object at all. Cool! :)
Thank you very much......
I like this.
what makes the reading emitted? is it the createReadStream? in this case aren't we losing the first chunks that come before we used "on" to listen ? i feel like we need to listen first and then start the reading. what am i missing?
I was curious about this so I asked chatgpt and it explained it nicely. Basically the streaming won't start until the entire module/file is executed. So it's guaranteed that you won't lose any buffer/bytes at all.
In Node.js when you call `fs.createReadStream()`, it sets up the stream, but the streaming of data (i.e., the reading of data from the file and emitting it as `data` events) does not start immediately at the moment of this call. Instead, the streaming process begins later, allowing you to set up your event listeners in the meantime.
# Understanding the Flow
1. Creating the Stream: `fs.createReadStream()` creates a readable stream but doesn't immediately start reading data from the file. It just initializes the stream and gets it ready to read data.
2. Event Loop Integration: The actual reading of data is integrated with the Node.js event loop. The stream starts reading data when it gets an opportunity to execute within the event loop. This typically happens after the current executing script i.e. the current module/file (including all synchronous code and immediate function calls) completes.
3. Attaching Event Listeners: This delay before streaming starts allows you to attach event listeners like `readableStream.on('data', callback)`. If the stream started emitting data immediately upon creation, there would be a risk of missing early `data` events before the listeners are set up.
4. Starting the Stream: The stream effectively starts when Node.js's event loop processes it, which happens after the current tick of the event loop. This behavior ensures that you can attach `data`, `error`, `end`, and other event listeners in the same tick of the event loop as the stream creation, without missing any events.
# Example
const readableStream = fs.createReadStream(__dirname + "/readme.txt");
// Even though the stream is created, it hasn't started emitting 'data' events yet.
readableStream.on('data', function (block) {
console.log("new blocks received:");
console.log(block);
});
// The 'data' events will start after this point, when the Node.js event loop begins processing the stream.
In this example, the `data` event listener is attached immediately after creating the stream, ensuring that you won't miss any of the `data` events once the stream starts emitting them.
If I finish this course and understand it, am I able to get a job working with Node.js or is there a lot more to it than this?
a lot more you need to practice
@@pozeraczstivow6348 I pretty much gave up on node.js for right now. I'm coming from JavaScript/PHP/MySQL background and I think I prefer PHP after learning Node.
@@nick_jacob NO NO NO IDK IM DRUNK IM VRFRONTEDND I LOVE JAVASCIPRT ANAD IM BASIC REACT IDK LIFE SIS DAD
You can also get text by this .
myReadStream.on('data', function(chunk){
console.log('new chunk recieved: ' + chunk);
});
Thanks for the tip. I used template string for mine:
myReadStream.on('data', function(chunk){
console.log(`New chunk received: ${chunk}`)
})
why this is "on" event, not an "emit" event to trigger it happen??
I guess "emit" is used to fire "user-defined" events, whereas "data" is already defined.
It's because the event is most likely emitted somewhere inside the 'fs' module or some other core module.
@@harishpillarisetti6658 correct
awesome
Can anyone please tell me why he didnt use
my ReadStream.emit(data , chunk); ???
becuase in 8th tutorial he kinda use all three
the event emitter,the binder (.on) and the .emit.
can we send a request from another file? ive tried to do this and it tells me the "require" function is undefined, do i have to tell my files to use node-js somehow?? thank you for the videos!!
how can we determine the size of a chunk ?
Using higherwatermark option after the path in the readstream
Do you or can you do one similar to this but with csv with large file size? Something like 32,000KB? I'm having issues with these chunks and it appears the stream just stops.
i have audio file chunks coming in server and i want to play audio from that chunks on the client but unable to do please can you tell me how can i.
Is there a way to stream multiple files in a directory into a single file by this method?
What is emitting the data event to myReadStream?
I only received one chunk as against NetNinja's two chunks. Is it because I'm using a more recent Node.js version?
One question boss, since we are in the folder what happened if we use only the file name without __dirname ?
thanks
May I know how the event was executed without emitting it, don't we need to emit it like the emitter?
fs.createReadStream() function's implementation internally emits the data.
We can use ON & EMIT even we did not use events.Emitter, so why we have eventsEmitter, plesase help me to understand it
It's because 'fs' module inherits emit - meaning that it includes it without specifying seperately.
thank you bro ^^ i got it
This is an old video but I'm hoping someone may be able to answer this: When exactly does an event listener stop listening? For example what if the data event we're listening for in the tutorial never fires? When I arbitrarily cause it to never fire in my code, the program exits out very quickly, which confuses me because if the whole point of event listeners is to listen out for events, shouldn't it just listen indefinitely, similar to how running listen() on an http.Server object causes your program to remain open indefinitely?
This is an old video, you said it. You won't find answers here. Go to reddit or something.
can you explain reading json file, where i manipulate some data then it will write that manipulated data. Because it is storing chucks of data i could not modify my json data. i have 54940 records while readStream it is storing 643 records in first chunk, where the last record is not complete json(example-->{ "_id" : "PERFSTG26226", "bonuses" : [ ) where my json data is incomplete. how can i read exactly if it is storing size wise not according to number of records.
i am new to node.js and want to ask, why need to require http as first line of code 'cos in this example, i am not seeing it being use. is there depecencies over at the fs ?
Mike Wong There is no need it just their as a place holder
Why would you use streams if you can just read files using the fs module?
PJ Collazo .
He explained it near the end of the video. It's so the user can start reading the data before it's fully read.
Useful when they want to read a really big file (like a video) or they're on a really slow connection.
How did he use on function without calling the module above?
And how is that on function running without using emit.
I am confused.
because readStream inherits from EventEmitter class where "data" is an event.
He DID call the module above.
myReadStream is actually *fs*.something
myReadStream.on() would in this case be the same as fs.something.on()
By chunks we mean packages, right?
I want to get data about songs currently playing from a radio station. Like getting data from a streaming URL that looks like s2.randomname.com:7392. How do I do this?
love it
is there any functions for read pdf file insted of txt file...???
why does Node.js force us to stream data rather than buffer it ?
what are the difference b/w these two ?
why performance is good in streams as compared to buffer ?
A stream is just packets of data being sent across the connection. So if you are sending some text from the server to the client like:
The quick brown fox jumps over the lazy dog
And your buffer is 1 byte, then you will just send one character at a time. If it is 5 bytes, you will send:
"The q"
"uick "
"brown"
" fox "
"jumps"
" over"
" the "
"lazy "
"dog"
Try to think of each chunk as a box of data, and think of all the data boxes received so far as the buffer. The stream is just the process of transferring of the boxes sequentially from the client to the server. So as soon as the client program receives the first chunk, it can display The q, then The quick , then The quick brown, etc, etc. The buffers ARE the stream. But normally a program, like a web browser, will wait until all the data is received to display the web page (imagine what the page would look like if only half the code is there). But if you are sending audio or video, the browser will start displaying whatever it has received so far once there is enough data in the buffer. The process is essentially the same whether you are sending text data or video data, because all the data is sent as bytes. It is up to the client to interpret them. When you stream a video online and it says "buffering", it means your browser is processing and playing the video/audio data quicker than it is being downloaded, so you got to the last chunk and now you have to wait for a bunch of new packets to come in from the server (ie, it's loading new data into a buffer that you can start reading from again). You have 'consumed' all the data in all the boxes you have received, and it won't start streaming again until it receives a certain amount of data to give you a good new buffer.
If you think about it, all data transfer from a server to a client is a stream, and all the data received so far on the client-side is the buffer. Even if you sent a stream of characters one at a time, as soon as you receive 1 character, you are filling your buffer, even if you consume it immediately. The buffer is just some temporary space in memory to store the data you've received. Then the data can be displayed to you, or saved to the disk, cached, etc.
why aren't we considering public while giving path since __dirname adds only node-js-playlist
HI. I have a question. How we can see how works buffer with chunks without FileSystem module, but only with stream module
For example
const { Readable } = require('stream');
class Ever extends Readable {
constructor(opt) {
super(opt)
}
_read(chunks) {
....
}
let myRead = new Ever({});
myRead.on('data', (chunks) => {
console.log('Received: ');
console.log(chunks);
});
Hey my question is if I wanted to wait lets say 2 seconds after every chunk read, how would I do that?
Hey, did u find an answer for this?
@@aldrinjenson stackoverflow.com/questions/59467912/wait-after-every-read-of-a-chunk-of-data-node-js
why to specify directory name here,, can't we read a file using readstream by writing the file name only??
Can anyone help... If I want to bold the text in console.log('Hey there'); then what should I use?
If you want to read a .json file could you use .createReadStream or should you use readFile/Sync? What's the real difference between the two?
do we really need to include "var http = require('http');" in code,my code just worked fine.let me know if i m missing something. thanks in advance
U don't need http
How do I create a read stream with buffer of exactly one line?
// guys ignore this
const http = require('http');
const fs = require('fs');
// createReadStream inherits from events.EventEmitter
let myReadStream = fs.createReadStream(__dirname + '/readMe.txt' , 'utf8'); // if utf8 is not mentioned bytes will be returned
// Every time when a stream is ready it emits an event names data
myReadStream.on('data', function(chunk){ // listening for 'data'
console.log('new chunk: ' );
console.log(chunk);
}
Nice :D
what is the size of each chunk
the heightest water marker is probaliy 1024 or 1kb
How is the myReadStream data event emitted?
View this link for more information nodejs.org/api/all.html#fs_fs_createreadstream_path_options
When I concatenate the chunk with “new data received:” it logs the whole text. Can you give a explanation?
Because it cast it to String type
Great
Why you do not emit this data event
How would you know when to emit it? You wouldn't, because it's a builtin functionality. You can emit your own events like in the previous tutorials, but node can also emit events, which you can make your script listen for, just like you can listen for events in a browser in javascript (ie. onload, onclick, etc.). Think of this as ondata
why he not imported events module ???
how to remove particular line from file ?
file.text
1 abc def
2 abc def
3 abc def
4 abc def
after deleting(3rd line removed)
1 abc def
2 abc def
4 abc def
I tried concatenating [ console.log(chunk, + 'New chunk recieved:'); ] and got the text then a NaN value. Then i tried [ console.log('New chunk recieved:', + chunk); ] and got New chunk recieved: NaN
New chunk recieved: NaN. Why does this happen? I know NaN means Not A Number.
Also when I used Chalk to change the colour of the output I didnt need to insert 'utf8' it automatically changes the encoding to 'utf8' for you.
What are those inside buffer bracket is called. 4c 6f 72 65 blah blah blah.
Only getting one chunk
can anyone tell me what is the accent
I only get one "new chunk received:" and under it is the whole text. Without the 'utf8', it says:
My Lorem_Ipsum.txt is 53kB. Why does it read it all at once? How do I split it into more than one chunk?
For anyone else wondering about this, I've found the answer. Visual Studio Code says: "Unlike the 16 kb default highWaterMark for a stream.Readable, the stream returned by this method has a default highWaterMark of 64 kb."
So I copy-pasted the whole file's contents so it's 106kB and now it makes 2 chunks :)
One step closer to understanding it all.
thanks