‫Welcome back!
‫In this video, we're gonna read files and write two files
‫just like before, but instead in an asynchronous way.
‫Let's add some comments here before.
‫So, this is the blocking,
‫synchronous way, and then, we will do an exercise
‫in an non-blocking, asynchronous way.
‫So, we're not gonna do the same thing,
‫we're just gonna invent some other
‫kind of crazy exercise here.
‫So, to read a file in an asynchronous way,
‫it works like this.
‫Again, we need the FS module, and then read file,
‫but this time, not read file sync, of course.
‫And, again, we pass in the name of the file,
‫or the path to the file actually,
‫and so again, it is txt,
‫and the file that I want right now is called start.txt,
‫so this one.
‫Oops, sorry for that.
‫So, this is the file that I want, on the task is read this,
‫and I'm gonna explain to you why a bit later.
‫For now, don't worry about the content here.
‫So, in the read file,
‫we actually do not have to specify the file encoding, okay.
‫And so, the next parameter,
‫the second one will be a callback function,
‫and that is what we learned in the last lecture.
‫So, Node JS is all built around callbacks
‫in order to implement an asynchronous behavior,
‫and this is how it works.
‫So, Node will start reading this file here
‫in the background, and as soon as it is ready,
‫it will start the callback function that we specify here.
‫Okay, and it calls this callback function
‫with two arguments.
‫The first one is the error,
‫and the second one is the actual data, okay?
‫So, this error first callback style is
‫very typical in Node JS, okay.
‫So, many, many times, the first parameter
‫in a callback will be the error, in case there was any,
‫and the second one will then be the data, itself.
‫What matters here is
‫that the error is usually always the first one, okay?
‫And so just to test it out for now,
‫let's simply log through console, the data.
‫And so, let's now actually test that.
‫But, before we do this,
‫let us actually still specify the filing coding here, okay?
‫So, I'm not one hundred percent sure
‫that it works without this,
‫so clean this now, run it again, and here we see read this.
‫So, let's analyze, again, what happened here.
‫As soon as this function here is run,
‫it will start reading this file in the background
‫without blocking the rest of the code execution.
‫So, let me actually demonstrate this here.
‫So, a console.log
‫will read file, and just to have a bit less confusion there,
‫let me comment out this part here, okay.
‫And so, what do you think will happen now?
‫What log are we gonna see first?
‫And indeed, first we see will read file,
‫and, only then, we see read this.
‫So, again, why did that happen?
‫So, as I mentioned Node JS will start reading the file
‫in the background here, and will not block the code,
‫and will then immediately move on to the next line of code.
‫And, the next line of code, well, it's this log here,
‫and so that is the first thing
‫that will be logged here to the terminal.
‫Only then, when a file is completely read,
‫this callback function here will run, okay?
‫And again, this callback function has access to the error
‫and the data that was read,
‫and we could really call this here anything that we wanted.
‫We could call it text as well, it doesn't really matter,
‫all that matters is that it is the second argument
‫in this callback function.
‫Let's actually go back to data
‫because I like that way better.
‫And so, only then, this console.log will run with the data,
‫so with the text that was in the file.
‫And so, that's why we see this here as the second log.
‫All right, now to take it even further,
‫let's actually do another read file, but instead of this,
‫so that I can show you we can basically do
‫multiple steps, one after the other, with callbacks.
‫So, steps that depend upon the result of the previous step.
‫Okay, so that's why actually in the start file,
‫I have read this
‫because then there is a file called read this,
‫which has the content that we're actually interested in.
‫Okay?
‫So, what I'm gonna to do here is to copy this code,
‫and put it in here.
‫I'm gonna call this one data one, and then data two,
‫and the result of the second step, so the second file read,
‫will depend on the first one.
‫That's because we will use the data for file name, remember?
‫So, here we are doing a (mumbles) now
‫because we need to put in that variable, and it is called
‫data one.
‫Okay, make sense?
‫So, data one will be read this, okay,
‫and so then, in the next step, we read txt/readthis.txt,
‫which is then this.
‫Okay, and so that's why this file name here is
‫the same as this content.
‫And so, that's logged through console data to that.
‫And, let's quickly test if this works,
‫and indeed, so that is the content of read this.txt.
‫And, now I'm actually gonna take it one step further even
‫because there's some other text in this append file
‫that I want to add to this first string,
‫so there's text coming from the other file.
‫And so, we have yet another step
‫that depends on the previous step,
‫so what I'm gonna do is to add another read file in here.
‫So, just like this.
‫So, this one is called append,
‫and I'm gonna call this one the data three, data three here,
‫and so that's, again, run that.
‫And, okay, so now we have these two results here.
‫All right, and now finally, as the last step,
‫I want to write these two strings together
‫into a file, okay?
‫So far, we have only read files,
‫but I want to write a file as well,
‫so let's do that right here as well.
‫So, fs.writeFile,
‫and of course, we're not using the synchronous one
‫like we did before,
‫but again we use, just like here and here and here,
‫we use the asynchronous version, not the synchronous one.
‫So, txt slash, missing this one here,
‫final.
‫Then, we should add the texting coding here as well,
‫and then this one also accepts a callback function,
‫but in this case there is no data that we read,
‫and so, we don't need two arguments.
‫So, the only argument that we have is the error, actually.
‫Okay, so here we have the error, and the data that was read,
‫but here in writeFile, there is no data.
‫All that there is, or can be, is an error, okay?
‫And actually, we're missing something here,
‫which is what we actually want to write to the file.
‫Okay, and so that is the second argument,
‫and what that is, is data two and data three.
‫So, again a (mumbles) string here,
‫data two,
‫then a new line character, which again, is backslash n,
‫and then data 3.
‫All right, and so, just like with the read file functions,
‫then this callback is what's run at the end,
‫so what I'm gonna do here is to simply log through console
‫that the files have been written,
‫or that the file has been written.
‫Your file has been written,
‫and let's just use some fun emoji here,
‫just to make the console a bit brighter for us,
‫and I think we should be done like this.
‫So, let's clear the console one more time, run it,
‫and indeed we see your file has been written.
‫So, has it really?
‫Final.
‫Oh, yeah, here it is.
‫So, that is the read this text,
‫and the append text, both together, both in the same file.
‫Okay, so that is how we perform multiple steps in orders,
‫using callback functions, right?
‫Because imagine that you simply did the same file read,
‫and then the second file read, so this one,
‫right after that.
‫Well, how would you then get access to the data
‫from the first one, right?
‫And so, that is how this pattern emerges.
‫It actually has it's own name,
‫and I think I mentioned that in the last video,
‫it is the called callback hell,
‫and there are some solutions to make this code here
‫more readable and better to understand,
‫but for now, that doesn't matter at all for you.
‫What matters is that Node JS is built around
‫this philosophy of callbacks,
‫so that is how Node JS implements asynchronous operations,
‫by calling callbacks as soon as the operation
‫that it's doing has been finished.
‫And, by the way, this way of writing function
‫that you see here, again,
‫in case you're not familiar with it,
‫it is the new ES6 syntax as well, okay?
‫So, again, I hope that you are familiar
‫with ES6 at this point,
‫and so that all of this makes complete sense to you.
‫If you were to write this function here
‫without the error function syntax, we would do
‫simply like this, function, err, data one,
‫and then like this.
‫So, that is a normal function,
‫let's say an old-fashioned function,
‫and the new version works like this.
‫The difference between them is mainly the syntax,
‫but also the fact that an error function,
‫so this kind of function,
‫doesn't get it's own disk keyword,
‫so it uses the disk keyword from the parent function.
‫And, that is called the lexical disk keyword,
‫while a normal function like this one always gets
‫its own disk keyword, right?
‫I'm sure you're familiar with that kind of stuff,
‫but just doing a small review here in case you're not.
‫Okay, I hope that made since.
‫We did actually never use this error,
‫we didn't handle any errors,
‫so, for example, imagine that this file here did not exist.
‫Well we could have used this error,
‫and let's actually do that, but just for this one here,
‫so I don't wanna create all of these error handlers here,
‫but just in this situation, let's say there was an error,
‫and so let's say if error,
‫the return from this function, so do nothing else,
‫and log to the console,
‫error, and then we can add some other emoji here,
‫like this explosion, so like something exploded here.
‫So, let's now change this here, like start.txt,
‫run this again,
‫and so, we have this error now,
‫so it gives us this log to the console,
‫and since we did return, it will not do anything after that,
‫so all of this is basically ignored and will not run,
‫which is exactly what we want.
‫Right, but if we put it back to normal,
‫and then run it again,
‫well then, everything works just like before.
‫So, get used to this pattern of callbacks
‫because you will see it all over the place in Node JS
‫and throughout this section.